#![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 TronGetAddress {
pub address_n: ::std::vec::Vec<u32>,
show_display: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronGetAddress {
fn default() -> &'a TronGetAddress {
<TronGetAddress as ::protobuf::Message>::default_instance()
}
}
impl TronGetAddress {
pub fn new() -> TronGetAddress {
::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_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);
}
}
impl ::protobuf::Message for TronGetAddress {
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 => {
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);
},
_ => {
::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(v) = self.show_display {
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(v) = self.show_display {
os.write_bool(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() -> TronGetAddress {
TronGetAddress::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: &TronGetAddress| { &m.address_n },
|m: &mut TronGetAddress| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"show_display",
|m: &TronGetAddress| { &m.show_display },
|m: &mut TronGetAddress| { &mut m.show_display },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronGetAddress>(
"TronGetAddress",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronGetAddress {
static instance: ::protobuf::rt::LazyV2<TronGetAddress> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronGetAddress::new)
}
}
impl ::protobuf::Clear for TronGetAddress {
fn clear(&mut self) {
self.address_n.clear();
self.show_display = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronGetAddress {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronGetAddress {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronAddress {
address: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronAddress {
fn default() -> &'a TronAddress {
<TronAddress as ::protobuf::Message>::default_instance()
}
}
impl TronAddress {
pub fn new() -> TronAddress {
::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 TronAddress {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.address)?;
},
_ => {
::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() -> TronAddress {
TronAddress::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: &TronAddress| { &m.address },
|m: &mut TronAddress| { &mut m.address },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronAddress>(
"TronAddress",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronAddress {
static instance: ::protobuf::rt::LazyV2<TronAddress> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronAddress::new)
}
}
impl ::protobuf::Clear for TronAddress {
fn clear(&mut self) {
self.address.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronAddress {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronAddress {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx {
pub address_n: ::std::vec::Vec<u32>,
ref_block_bytes: ::protobuf::SingularField<::std::vec::Vec<u8>>,
ref_block_hash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
expiration: ::std::option::Option<u64>,
data: ::protobuf::SingularField<::std::string::String>,
pub contract: ::protobuf::SingularPtrField<TronSignTx_TronContract>,
timestamp: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx {
fn default() -> &'a TronSignTx {
<TronSignTx as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx {
pub fn new() -> TronSignTx {
::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_ref_block_bytes(&self) -> &[u8] {
match self.ref_block_bytes.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ref_block_bytes(&mut self) {
self.ref_block_bytes.clear();
}
pub fn has_ref_block_bytes(&self) -> bool {
self.ref_block_bytes.is_some()
}
pub fn set_ref_block_bytes(&mut self, v: ::std::vec::Vec<u8>) {
self.ref_block_bytes = ::protobuf::SingularField::some(v);
}
pub fn mut_ref_block_bytes(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ref_block_bytes.is_none() {
self.ref_block_bytes.set_default();
}
self.ref_block_bytes.as_mut().unwrap()
}
pub fn take_ref_block_bytes(&mut self) -> ::std::vec::Vec<u8> {
self.ref_block_bytes.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_ref_block_hash(&self) -> &[u8] {
match self.ref_block_hash.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_ref_block_hash(&mut self) {
self.ref_block_hash.clear();
}
pub fn has_ref_block_hash(&self) -> bool {
self.ref_block_hash.is_some()
}
pub fn set_ref_block_hash(&mut self, v: ::std::vec::Vec<u8>) {
self.ref_block_hash = ::protobuf::SingularField::some(v);
}
pub fn mut_ref_block_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.ref_block_hash.is_none() {
self.ref_block_hash.set_default();
}
self.ref_block_hash.as_mut().unwrap()
}
pub fn take_ref_block_hash(&mut self) -> ::std::vec::Vec<u8> {
self.ref_block_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_expiration(&self) -> u64 {
self.expiration.unwrap_or(0)
}
pub fn clear_expiration(&mut self) {
self.expiration = ::std::option::Option::None;
}
pub fn has_expiration(&self) -> bool {
self.expiration.is_some()
}
pub fn set_expiration(&mut self, v: u64) {
self.expiration = ::std::option::Option::Some(v);
}
pub fn get_data(&self) -> &str {
match self.data.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_data(&mut self) {
self.data.clear();
}
pub fn has_data(&self) -> bool {
self.data.is_some()
}
pub fn set_data(&mut self, v: ::std::string::String) {
self.data = ::protobuf::SingularField::some(v);
}
pub fn mut_data(&mut self) -> &mut ::std::string::String {
if self.data.is_none() {
self.data.set_default();
}
self.data.as_mut().unwrap()
}
pub fn take_data(&mut self) -> ::std::string::String {
self.data.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_contract(&self) -> &TronSignTx_TronContract {
self.contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract as ::protobuf::Message>::default_instance())
}
pub fn clear_contract(&mut self) {
self.contract.clear();
}
pub fn has_contract(&self) -> bool {
self.contract.is_some()
}
pub fn set_contract(&mut self, v: TronSignTx_TronContract) {
self.contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_contract(&mut self) -> &mut TronSignTx_TronContract {
if self.contract.is_none() {
self.contract.set_default();
}
self.contract.as_mut().unwrap()
}
pub fn take_contract(&mut self) -> TronSignTx_TronContract {
self.contract.take().unwrap_or_else(|| TronSignTx_TronContract::new())
}
pub fn get_timestamp(&self) -> u64 {
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: u64) {
self.timestamp = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx {
fn is_initialized(&self) -> bool {
for v in &self.contract {
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.ref_block_bytes)?;
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ref_block_hash)?;
},
4 => {
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.expiration = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.data)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.contract)?;
},
7 => {
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.timestamp = ::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.ref_block_bytes.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(ref v) = self.ref_block_hash.as_ref() {
my_size += ::protobuf::rt::bytes_size(3, &v);
}
if let Some(v) = self.expiration {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.data.as_ref() {
my_size += ::protobuf::rt::string_size(5, &v);
}
if let Some(ref v) = self.contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.address_n {
os.write_uint32(1, *v)?;
};
if let Some(ref v) = self.ref_block_bytes.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(ref v) = self.ref_block_hash.as_ref() {
os.write_bytes(3, &v)?;
}
if let Some(v) = self.expiration {
os.write_uint64(4, v)?;
}
if let Some(ref v) = self.data.as_ref() {
os.write_string(5, &v)?;
}
if let Some(ref v) = self.contract.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(v) = self.timestamp {
os.write_uint64(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() -> TronSignTx {
TronSignTx::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: &TronSignTx| { &m.address_n },
|m: &mut TronSignTx| { &mut m.address_n },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ref_block_bytes",
|m: &TronSignTx| { &m.ref_block_bytes },
|m: &mut TronSignTx| { &mut m.ref_block_bytes },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"ref_block_hash",
|m: &TronSignTx| { &m.ref_block_hash },
|m: &mut TronSignTx| { &mut m.ref_block_hash },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"expiration",
|m: &TronSignTx| { &m.expiration },
|m: &mut TronSignTx| { &mut m.expiration },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"data",
|m: &TronSignTx| { &m.data },
|m: &mut TronSignTx| { &mut m.data },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract>>(
"contract",
|m: &TronSignTx| { &m.contract },
|m: &mut TronSignTx| { &mut m.contract },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"timestamp",
|m: &TronSignTx| { &m.timestamp },
|m: &mut TronSignTx| { &mut m.timestamp },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx>(
"TronSignTx",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx {
static instance: ::protobuf::rt::LazyV2<TronSignTx> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx::new)
}
}
impl ::protobuf::Clear for TronSignTx {
fn clear(&mut self) {
self.address_n.clear();
self.ref_block_bytes.clear();
self.ref_block_hash.clear();
self.expiration = ::std::option::Option::None;
self.data.clear();
self.contract.clear();
self.timestamp = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract {
pub transfer_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronTransferContract>,
pub transfer_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronTransferAssetContract>,
pub vote_witness_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronVoteWitnessContract>,
pub witness_create_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWitnessCreateContract>,
pub asset_issue_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronAssetIssueContract>,
pub witness_update_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWitnessUpdateContract>,
pub participate_asset_issue_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronParticipateAssetIssueContract>,
pub account_update_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronAccountUpdateContract>,
pub freeze_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronFreezeBalanceContract>,
pub unfreeze_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUnfreezeBalanceContract>,
pub withdraw_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWithdrawBalanceContract>,
pub unfreeze_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUnfreezeAssetContract>,
pub update_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUpdateAssetContract>,
pub proposal_create_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalCreateContract>,
pub proposal_approve_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalApproveContract>,
pub proposal_delete_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalDeleteContract>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract {
fn default() -> &'a TronSignTx_TronContract {
<TronSignTx_TronContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract {
pub fn new() -> TronSignTx_TronContract {
::std::default::Default::default()
}
pub fn get_transfer_contract(&self) -> &TronSignTx_TronContract_TronTransferContract {
self.transfer_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronTransferContract as ::protobuf::Message>::default_instance())
}
pub fn clear_transfer_contract(&mut self) {
self.transfer_contract.clear();
}
pub fn has_transfer_contract(&self) -> bool {
self.transfer_contract.is_some()
}
pub fn set_transfer_contract(&mut self, v: TronSignTx_TronContract_TronTransferContract) {
self.transfer_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_transfer_contract(&mut self) -> &mut TronSignTx_TronContract_TronTransferContract {
if self.transfer_contract.is_none() {
self.transfer_contract.set_default();
}
self.transfer_contract.as_mut().unwrap()
}
pub fn take_transfer_contract(&mut self) -> TronSignTx_TronContract_TronTransferContract {
self.transfer_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronTransferContract::new())
}
pub fn get_transfer_asset_contract(&self) -> &TronSignTx_TronContract_TronTransferAssetContract {
self.transfer_asset_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronTransferAssetContract as ::protobuf::Message>::default_instance())
}
pub fn clear_transfer_asset_contract(&mut self) {
self.transfer_asset_contract.clear();
}
pub fn has_transfer_asset_contract(&self) -> bool {
self.transfer_asset_contract.is_some()
}
pub fn set_transfer_asset_contract(&mut self, v: TronSignTx_TronContract_TronTransferAssetContract) {
self.transfer_asset_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_transfer_asset_contract(&mut self) -> &mut TronSignTx_TronContract_TronTransferAssetContract {
if self.transfer_asset_contract.is_none() {
self.transfer_asset_contract.set_default();
}
self.transfer_asset_contract.as_mut().unwrap()
}
pub fn take_transfer_asset_contract(&mut self) -> TronSignTx_TronContract_TronTransferAssetContract {
self.transfer_asset_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronTransferAssetContract::new())
}
pub fn get_vote_witness_contract(&self) -> &TronSignTx_TronContract_TronVoteWitnessContract {
self.vote_witness_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronVoteWitnessContract as ::protobuf::Message>::default_instance())
}
pub fn clear_vote_witness_contract(&mut self) {
self.vote_witness_contract.clear();
}
pub fn has_vote_witness_contract(&self) -> bool {
self.vote_witness_contract.is_some()
}
pub fn set_vote_witness_contract(&mut self, v: TronSignTx_TronContract_TronVoteWitnessContract) {
self.vote_witness_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_vote_witness_contract(&mut self) -> &mut TronSignTx_TronContract_TronVoteWitnessContract {
if self.vote_witness_contract.is_none() {
self.vote_witness_contract.set_default();
}
self.vote_witness_contract.as_mut().unwrap()
}
pub fn take_vote_witness_contract(&mut self) -> TronSignTx_TronContract_TronVoteWitnessContract {
self.vote_witness_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronVoteWitnessContract::new())
}
pub fn get_witness_create_contract(&self) -> &TronSignTx_TronContract_TronWitnessCreateContract {
self.witness_create_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronWitnessCreateContract as ::protobuf::Message>::default_instance())
}
pub fn clear_witness_create_contract(&mut self) {
self.witness_create_contract.clear();
}
pub fn has_witness_create_contract(&self) -> bool {
self.witness_create_contract.is_some()
}
pub fn set_witness_create_contract(&mut self, v: TronSignTx_TronContract_TronWitnessCreateContract) {
self.witness_create_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_witness_create_contract(&mut self) -> &mut TronSignTx_TronContract_TronWitnessCreateContract {
if self.witness_create_contract.is_none() {
self.witness_create_contract.set_default();
}
self.witness_create_contract.as_mut().unwrap()
}
pub fn take_witness_create_contract(&mut self) -> TronSignTx_TronContract_TronWitnessCreateContract {
self.witness_create_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronWitnessCreateContract::new())
}
pub fn get_asset_issue_contract(&self) -> &TronSignTx_TronContract_TronAssetIssueContract {
self.asset_issue_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronAssetIssueContract as ::protobuf::Message>::default_instance())
}
pub fn clear_asset_issue_contract(&mut self) {
self.asset_issue_contract.clear();
}
pub fn has_asset_issue_contract(&self) -> bool {
self.asset_issue_contract.is_some()
}
pub fn set_asset_issue_contract(&mut self, v: TronSignTx_TronContract_TronAssetIssueContract) {
self.asset_issue_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_asset_issue_contract(&mut self) -> &mut TronSignTx_TronContract_TronAssetIssueContract {
if self.asset_issue_contract.is_none() {
self.asset_issue_contract.set_default();
}
self.asset_issue_contract.as_mut().unwrap()
}
pub fn take_asset_issue_contract(&mut self) -> TronSignTx_TronContract_TronAssetIssueContract {
self.asset_issue_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronAssetIssueContract::new())
}
pub fn get_witness_update_contract(&self) -> &TronSignTx_TronContract_TronWitnessUpdateContract {
self.witness_update_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronWitnessUpdateContract as ::protobuf::Message>::default_instance())
}
pub fn clear_witness_update_contract(&mut self) {
self.witness_update_contract.clear();
}
pub fn has_witness_update_contract(&self) -> bool {
self.witness_update_contract.is_some()
}
pub fn set_witness_update_contract(&mut self, v: TronSignTx_TronContract_TronWitnessUpdateContract) {
self.witness_update_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_witness_update_contract(&mut self) -> &mut TronSignTx_TronContract_TronWitnessUpdateContract {
if self.witness_update_contract.is_none() {
self.witness_update_contract.set_default();
}
self.witness_update_contract.as_mut().unwrap()
}
pub fn take_witness_update_contract(&mut self) -> TronSignTx_TronContract_TronWitnessUpdateContract {
self.witness_update_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronWitnessUpdateContract::new())
}
pub fn get_participate_asset_issue_contract(&self) -> &TronSignTx_TronContract_TronParticipateAssetIssueContract {
self.participate_asset_issue_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronParticipateAssetIssueContract as ::protobuf::Message>::default_instance())
}
pub fn clear_participate_asset_issue_contract(&mut self) {
self.participate_asset_issue_contract.clear();
}
pub fn has_participate_asset_issue_contract(&self) -> bool {
self.participate_asset_issue_contract.is_some()
}
pub fn set_participate_asset_issue_contract(&mut self, v: TronSignTx_TronContract_TronParticipateAssetIssueContract) {
self.participate_asset_issue_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_participate_asset_issue_contract(&mut self) -> &mut TronSignTx_TronContract_TronParticipateAssetIssueContract {
if self.participate_asset_issue_contract.is_none() {
self.participate_asset_issue_contract.set_default();
}
self.participate_asset_issue_contract.as_mut().unwrap()
}
pub fn take_participate_asset_issue_contract(&mut self) -> TronSignTx_TronContract_TronParticipateAssetIssueContract {
self.participate_asset_issue_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronParticipateAssetIssueContract::new())
}
pub fn get_account_update_contract(&self) -> &TronSignTx_TronContract_TronAccountUpdateContract {
self.account_update_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronAccountUpdateContract as ::protobuf::Message>::default_instance())
}
pub fn clear_account_update_contract(&mut self) {
self.account_update_contract.clear();
}
pub fn has_account_update_contract(&self) -> bool {
self.account_update_contract.is_some()
}
pub fn set_account_update_contract(&mut self, v: TronSignTx_TronContract_TronAccountUpdateContract) {
self.account_update_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_account_update_contract(&mut self) -> &mut TronSignTx_TronContract_TronAccountUpdateContract {
if self.account_update_contract.is_none() {
self.account_update_contract.set_default();
}
self.account_update_contract.as_mut().unwrap()
}
pub fn take_account_update_contract(&mut self) -> TronSignTx_TronContract_TronAccountUpdateContract {
self.account_update_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronAccountUpdateContract::new())
}
pub fn get_freeze_balance_contract(&self) -> &TronSignTx_TronContract_TronFreezeBalanceContract {
self.freeze_balance_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronFreezeBalanceContract as ::protobuf::Message>::default_instance())
}
pub fn clear_freeze_balance_contract(&mut self) {
self.freeze_balance_contract.clear();
}
pub fn has_freeze_balance_contract(&self) -> bool {
self.freeze_balance_contract.is_some()
}
pub fn set_freeze_balance_contract(&mut self, v: TronSignTx_TronContract_TronFreezeBalanceContract) {
self.freeze_balance_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_freeze_balance_contract(&mut self) -> &mut TronSignTx_TronContract_TronFreezeBalanceContract {
if self.freeze_balance_contract.is_none() {
self.freeze_balance_contract.set_default();
}
self.freeze_balance_contract.as_mut().unwrap()
}
pub fn take_freeze_balance_contract(&mut self) -> TronSignTx_TronContract_TronFreezeBalanceContract {
self.freeze_balance_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronFreezeBalanceContract::new())
}
pub fn get_unfreeze_balance_contract(&self) -> &TronSignTx_TronContract_TronUnfreezeBalanceContract {
self.unfreeze_balance_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronUnfreezeBalanceContract as ::protobuf::Message>::default_instance())
}
pub fn clear_unfreeze_balance_contract(&mut self) {
self.unfreeze_balance_contract.clear();
}
pub fn has_unfreeze_balance_contract(&self) -> bool {
self.unfreeze_balance_contract.is_some()
}
pub fn set_unfreeze_balance_contract(&mut self, v: TronSignTx_TronContract_TronUnfreezeBalanceContract) {
self.unfreeze_balance_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_unfreeze_balance_contract(&mut self) -> &mut TronSignTx_TronContract_TronUnfreezeBalanceContract {
if self.unfreeze_balance_contract.is_none() {
self.unfreeze_balance_contract.set_default();
}
self.unfreeze_balance_contract.as_mut().unwrap()
}
pub fn take_unfreeze_balance_contract(&mut self) -> TronSignTx_TronContract_TronUnfreezeBalanceContract {
self.unfreeze_balance_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronUnfreezeBalanceContract::new())
}
pub fn get_withdraw_balance_contract(&self) -> &TronSignTx_TronContract_TronWithdrawBalanceContract {
self.withdraw_balance_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronWithdrawBalanceContract as ::protobuf::Message>::default_instance())
}
pub fn clear_withdraw_balance_contract(&mut self) {
self.withdraw_balance_contract.clear();
}
pub fn has_withdraw_balance_contract(&self) -> bool {
self.withdraw_balance_contract.is_some()
}
pub fn set_withdraw_balance_contract(&mut self, v: TronSignTx_TronContract_TronWithdrawBalanceContract) {
self.withdraw_balance_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_withdraw_balance_contract(&mut self) -> &mut TronSignTx_TronContract_TronWithdrawBalanceContract {
if self.withdraw_balance_contract.is_none() {
self.withdraw_balance_contract.set_default();
}
self.withdraw_balance_contract.as_mut().unwrap()
}
pub fn take_withdraw_balance_contract(&mut self) -> TronSignTx_TronContract_TronWithdrawBalanceContract {
self.withdraw_balance_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronWithdrawBalanceContract::new())
}
pub fn get_unfreeze_asset_contract(&self) -> &TronSignTx_TronContract_TronUnfreezeAssetContract {
self.unfreeze_asset_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronUnfreezeAssetContract as ::protobuf::Message>::default_instance())
}
pub fn clear_unfreeze_asset_contract(&mut self) {
self.unfreeze_asset_contract.clear();
}
pub fn has_unfreeze_asset_contract(&self) -> bool {
self.unfreeze_asset_contract.is_some()
}
pub fn set_unfreeze_asset_contract(&mut self, v: TronSignTx_TronContract_TronUnfreezeAssetContract) {
self.unfreeze_asset_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_unfreeze_asset_contract(&mut self) -> &mut TronSignTx_TronContract_TronUnfreezeAssetContract {
if self.unfreeze_asset_contract.is_none() {
self.unfreeze_asset_contract.set_default();
}
self.unfreeze_asset_contract.as_mut().unwrap()
}
pub fn take_unfreeze_asset_contract(&mut self) -> TronSignTx_TronContract_TronUnfreezeAssetContract {
self.unfreeze_asset_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronUnfreezeAssetContract::new())
}
pub fn get_update_asset_contract(&self) -> &TronSignTx_TronContract_TronUpdateAssetContract {
self.update_asset_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronUpdateAssetContract as ::protobuf::Message>::default_instance())
}
pub fn clear_update_asset_contract(&mut self) {
self.update_asset_contract.clear();
}
pub fn has_update_asset_contract(&self) -> bool {
self.update_asset_contract.is_some()
}
pub fn set_update_asset_contract(&mut self, v: TronSignTx_TronContract_TronUpdateAssetContract) {
self.update_asset_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_update_asset_contract(&mut self) -> &mut TronSignTx_TronContract_TronUpdateAssetContract {
if self.update_asset_contract.is_none() {
self.update_asset_contract.set_default();
}
self.update_asset_contract.as_mut().unwrap()
}
pub fn take_update_asset_contract(&mut self) -> TronSignTx_TronContract_TronUpdateAssetContract {
self.update_asset_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronUpdateAssetContract::new())
}
pub fn get_proposal_create_contract(&self) -> &TronSignTx_TronContract_TronProposalCreateContract {
self.proposal_create_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronProposalCreateContract as ::protobuf::Message>::default_instance())
}
pub fn clear_proposal_create_contract(&mut self) {
self.proposal_create_contract.clear();
}
pub fn has_proposal_create_contract(&self) -> bool {
self.proposal_create_contract.is_some()
}
pub fn set_proposal_create_contract(&mut self, v: TronSignTx_TronContract_TronProposalCreateContract) {
self.proposal_create_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_proposal_create_contract(&mut self) -> &mut TronSignTx_TronContract_TronProposalCreateContract {
if self.proposal_create_contract.is_none() {
self.proposal_create_contract.set_default();
}
self.proposal_create_contract.as_mut().unwrap()
}
pub fn take_proposal_create_contract(&mut self) -> TronSignTx_TronContract_TronProposalCreateContract {
self.proposal_create_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronProposalCreateContract::new())
}
pub fn get_proposal_approve_contract(&self) -> &TronSignTx_TronContract_TronProposalApproveContract {
self.proposal_approve_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronProposalApproveContract as ::protobuf::Message>::default_instance())
}
pub fn clear_proposal_approve_contract(&mut self) {
self.proposal_approve_contract.clear();
}
pub fn has_proposal_approve_contract(&self) -> bool {
self.proposal_approve_contract.is_some()
}
pub fn set_proposal_approve_contract(&mut self, v: TronSignTx_TronContract_TronProposalApproveContract) {
self.proposal_approve_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_proposal_approve_contract(&mut self) -> &mut TronSignTx_TronContract_TronProposalApproveContract {
if self.proposal_approve_contract.is_none() {
self.proposal_approve_contract.set_default();
}
self.proposal_approve_contract.as_mut().unwrap()
}
pub fn take_proposal_approve_contract(&mut self) -> TronSignTx_TronContract_TronProposalApproveContract {
self.proposal_approve_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronProposalApproveContract::new())
}
pub fn get_proposal_delete_contract(&self) -> &TronSignTx_TronContract_TronProposalDeleteContract {
self.proposal_delete_contract.as_ref().unwrap_or_else(|| <TronSignTx_TronContract_TronProposalDeleteContract as ::protobuf::Message>::default_instance())
}
pub fn clear_proposal_delete_contract(&mut self) {
self.proposal_delete_contract.clear();
}
pub fn has_proposal_delete_contract(&self) -> bool {
self.proposal_delete_contract.is_some()
}
pub fn set_proposal_delete_contract(&mut self, v: TronSignTx_TronContract_TronProposalDeleteContract) {
self.proposal_delete_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_proposal_delete_contract(&mut self) -> &mut TronSignTx_TronContract_TronProposalDeleteContract {
if self.proposal_delete_contract.is_none() {
self.proposal_delete_contract.set_default();
}
self.proposal_delete_contract.as_mut().unwrap()
}
pub fn take_proposal_delete_contract(&mut self) -> TronSignTx_TronContract_TronProposalDeleteContract {
self.proposal_delete_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronProposalDeleteContract::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract {
fn is_initialized(&self) -> bool {
for v in &self.transfer_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.transfer_asset_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.vote_witness_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.witness_create_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.asset_issue_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.witness_update_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.participate_asset_issue_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.account_update_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.freeze_balance_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.unfreeze_balance_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.withdraw_balance_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.unfreeze_asset_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.update_asset_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.proposal_create_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.proposal_approve_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.proposal_delete_contract {
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.transfer_contract)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transfer_asset_contract)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.vote_witness_contract)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.witness_create_contract)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.asset_issue_contract)?;
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.witness_update_contract)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.participate_asset_issue_contract)?;
},
10 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.account_update_contract)?;
},
11 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.freeze_balance_contract)?;
},
12 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.unfreeze_balance_contract)?;
},
13 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.withdraw_balance_contract)?;
},
14 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.unfreeze_asset_contract)?;
},
15 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_asset_contract)?;
},
16 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.proposal_create_contract)?;
},
17 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.proposal_approve_contract)?;
},
18 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.proposal_delete_contract)?;
},
_ => {
::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.transfer_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.transfer_asset_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.vote_witness_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.witness_create_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.asset_issue_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.witness_update_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.participate_asset_issue_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.account_update_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.freeze_balance_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.unfreeze_balance_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.withdraw_balance_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.unfreeze_asset_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.update_asset_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.proposal_create_contract.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.proposal_approve_contract.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.proposal_delete_contract.as_ref() {
let len = v.compute_size();
my_size += 2 + ::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.transfer_contract.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.transfer_asset_contract.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.vote_witness_contract.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(ref v) = self.witness_create_contract.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.asset_issue_contract.as_ref() {
os.write_tag(6, ::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.witness_update_contract.as_ref() {
os.write_tag(8, ::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.participate_asset_issue_contract.as_ref() {
os.write_tag(9, ::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.account_update_contract.as_ref() {
os.write_tag(10, ::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.freeze_balance_contract.as_ref() {
os.write_tag(11, ::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.unfreeze_balance_contract.as_ref() {
os.write_tag(12, ::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.withdraw_balance_contract.as_ref() {
os.write_tag(13, ::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.unfreeze_asset_contract.as_ref() {
os.write_tag(14, ::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.update_asset_contract.as_ref() {
os.write_tag(15, ::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.proposal_create_contract.as_ref() {
os.write_tag(16, ::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.proposal_approve_contract.as_ref() {
os.write_tag(17, ::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.proposal_delete_contract.as_ref() {
os.write_tag(18, ::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() -> TronSignTx_TronContract {
TronSignTx_TronContract::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<TronSignTx_TronContract_TronTransferContract>>(
"transfer_contract",
|m: &TronSignTx_TronContract| { &m.transfer_contract },
|m: &mut TronSignTx_TronContract| { &mut m.transfer_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronTransferAssetContract>>(
"transfer_asset_contract",
|m: &TronSignTx_TronContract| { &m.transfer_asset_contract },
|m: &mut TronSignTx_TronContract| { &mut m.transfer_asset_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronVoteWitnessContract>>(
"vote_witness_contract",
|m: &TronSignTx_TronContract| { &m.vote_witness_contract },
|m: &mut TronSignTx_TronContract| { &mut m.vote_witness_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronWitnessCreateContract>>(
"witness_create_contract",
|m: &TronSignTx_TronContract| { &m.witness_create_contract },
|m: &mut TronSignTx_TronContract| { &mut m.witness_create_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronAssetIssueContract>>(
"asset_issue_contract",
|m: &TronSignTx_TronContract| { &m.asset_issue_contract },
|m: &mut TronSignTx_TronContract| { &mut m.asset_issue_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronWitnessUpdateContract>>(
"witness_update_contract",
|m: &TronSignTx_TronContract| { &m.witness_update_contract },
|m: &mut TronSignTx_TronContract| { &mut m.witness_update_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronParticipateAssetIssueContract>>(
"participate_asset_issue_contract",
|m: &TronSignTx_TronContract| { &m.participate_asset_issue_contract },
|m: &mut TronSignTx_TronContract| { &mut m.participate_asset_issue_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronAccountUpdateContract>>(
"account_update_contract",
|m: &TronSignTx_TronContract| { &m.account_update_contract },
|m: &mut TronSignTx_TronContract| { &mut m.account_update_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronFreezeBalanceContract>>(
"freeze_balance_contract",
|m: &TronSignTx_TronContract| { &m.freeze_balance_contract },
|m: &mut TronSignTx_TronContract| { &mut m.freeze_balance_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronUnfreezeBalanceContract>>(
"unfreeze_balance_contract",
|m: &TronSignTx_TronContract| { &m.unfreeze_balance_contract },
|m: &mut TronSignTx_TronContract| { &mut m.unfreeze_balance_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronWithdrawBalanceContract>>(
"withdraw_balance_contract",
|m: &TronSignTx_TronContract| { &m.withdraw_balance_contract },
|m: &mut TronSignTx_TronContract| { &mut m.withdraw_balance_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronUnfreezeAssetContract>>(
"unfreeze_asset_contract",
|m: &TronSignTx_TronContract| { &m.unfreeze_asset_contract },
|m: &mut TronSignTx_TronContract| { &mut m.unfreeze_asset_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronUpdateAssetContract>>(
"update_asset_contract",
|m: &TronSignTx_TronContract| { &m.update_asset_contract },
|m: &mut TronSignTx_TronContract| { &mut m.update_asset_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronProposalCreateContract>>(
"proposal_create_contract",
|m: &TronSignTx_TronContract| { &m.proposal_create_contract },
|m: &mut TronSignTx_TronContract| { &mut m.proposal_create_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronProposalApproveContract>>(
"proposal_approve_contract",
|m: &TronSignTx_TronContract| { &m.proposal_approve_contract },
|m: &mut TronSignTx_TronContract| { &mut m.proposal_approve_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronProposalDeleteContract>>(
"proposal_delete_contract",
|m: &TronSignTx_TronContract| { &m.proposal_delete_contract },
|m: &mut TronSignTx_TronContract| { &mut m.proposal_delete_contract },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract>(
"TronSignTx.TronContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract {
fn clear(&mut self) {
self.transfer_contract.clear();
self.transfer_asset_contract.clear();
self.vote_witness_contract.clear();
self.witness_create_contract.clear();
self.asset_issue_contract.clear();
self.witness_update_contract.clear();
self.participate_asset_issue_contract.clear();
self.account_update_contract.clear();
self.freeze_balance_contract.clear();
self.unfreeze_balance_contract.clear();
self.withdraw_balance_contract.clear();
self.unfreeze_asset_contract.clear();
self.update_asset_contract.clear();
self.proposal_create_contract.clear();
self.proposal_approve_contract.clear();
self.proposal_delete_contract.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAccountUpdateContract {
account_name: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronAccountUpdateContract {
fn default() -> &'a TronSignTx_TronContract_TronAccountUpdateContract {
<TronSignTx_TronContract_TronAccountUpdateContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronAccountUpdateContract {
pub fn new() -> TronSignTx_TronContract_TronAccountUpdateContract {
::std::default::Default::default()
}
pub fn get_account_name(&self) -> &str {
match self.account_name.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_account_name(&mut self) {
self.account_name.clear();
}
pub fn has_account_name(&self) -> bool {
self.account_name.is_some()
}
pub fn set_account_name(&mut self, v: ::std::string::String) {
self.account_name = ::protobuf::SingularField::some(v);
}
pub fn mut_account_name(&mut self) -> &mut ::std::string::String {
if self.account_name.is_none() {
self.account_name.set_default();
}
self.account_name.as_mut().unwrap()
}
pub fn take_account_name(&mut self) -> ::std::string::String {
self.account_name.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronAccountUpdateContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.account_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.account_name.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.account_name.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() -> TronSignTx_TronContract_TronAccountUpdateContract {
TronSignTx_TronContract_TronAccountUpdateContract::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>(
"account_name",
|m: &TronSignTx_TronContract_TronAccountUpdateContract| { &m.account_name },
|m: &mut TronSignTx_TronContract_TronAccountUpdateContract| { &mut m.account_name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronAccountUpdateContract>(
"TronSignTx.TronContract.TronAccountUpdateContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronAccountUpdateContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronAccountUpdateContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronAccountUpdateContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronAccountUpdateContract {
fn clear(&mut self) {
self.account_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronAccountUpdateContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronAccountUpdateContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronTransferContract {
to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
amount: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronTransferContract {
fn default() -> &'a TronSignTx_TronContract_TronTransferContract {
<TronSignTx_TronContract_TronTransferContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronTransferContract {
pub fn new() -> TronSignTx_TronContract_TronTransferContract {
::std::default::Default::default()
}
pub fn get_to_address(&self) -> &[u8] {
match self.to_address.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_to_address(&mut self) {
self.to_address.clear();
}
pub fn has_to_address(&self) -> bool {
self.to_address.is_some()
}
pub fn set_to_address(&mut self, v: ::std::vec::Vec<u8>) {
self.to_address = ::protobuf::SingularField::some(v);
}
pub fn mut_to_address(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.to_address.is_none() {
self.to_address.set_default();
}
self.to_address.as_mut().unwrap()
}
pub fn take_to_address(&mut self) -> ::std::vec::Vec<u8> {
self.to_address.take().unwrap_or_else(|| ::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);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronTransferContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.to_address)?;
},
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.amount = ::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.to_address.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
if let Some(v) = self.amount {
my_size += ::protobuf::rt::value_size(2, 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.to_address.as_ref() {
os.write_bytes(1, &v)?;
}
if let Some(v) = self.amount {
os.write_uint64(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() -> TronSignTx_TronContract_TronTransferContract {
TronSignTx_TronContract_TronTransferContract::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>(
"to_address",
|m: &TronSignTx_TronContract_TronTransferContract| { &m.to_address },
|m: &mut TronSignTx_TronContract_TronTransferContract| { &mut m.to_address },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TronSignTx_TronContract_TronTransferContract| { &m.amount },
|m: &mut TronSignTx_TronContract_TronTransferContract| { &mut m.amount },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronTransferContract>(
"TronSignTx.TronContract.TronTransferContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronTransferContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronTransferContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronTransferContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronTransferContract {
fn clear(&mut self) {
self.to_address.clear();
self.amount = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronTransferContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronTransferContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronTransferAssetContract {
asset_name: ::protobuf::SingularField<::std::string::String>,
to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
amount: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronTransferAssetContract {
fn default() -> &'a TronSignTx_TronContract_TronTransferAssetContract {
<TronSignTx_TronContract_TronTransferAssetContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronTransferAssetContract {
pub fn new() -> TronSignTx_TronContract_TronTransferAssetContract {
::std::default::Default::default()
}
pub fn get_asset_name(&self) -> &str {
match self.asset_name.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_asset_name(&mut self) {
self.asset_name.clear();
}
pub fn has_asset_name(&self) -> bool {
self.asset_name.is_some()
}
pub fn set_asset_name(&mut self, v: ::std::string::String) {
self.asset_name = ::protobuf::SingularField::some(v);
}
pub fn mut_asset_name(&mut self) -> &mut ::std::string::String {
if self.asset_name.is_none() {
self.asset_name.set_default();
}
self.asset_name.as_mut().unwrap()
}
pub fn take_asset_name(&mut self) -> ::std::string::String {
self.asset_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_to_address(&self) -> &[u8] {
match self.to_address.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_to_address(&mut self) {
self.to_address.clear();
}
pub fn has_to_address(&self) -> bool {
self.to_address.is_some()
}
pub fn set_to_address(&mut self, v: ::std::vec::Vec<u8>) {
self.to_address = ::protobuf::SingularField::some(v);
}
pub fn mut_to_address(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.to_address.is_none() {
self.to_address.set_default();
}
self.to_address.as_mut().unwrap()
}
pub fn take_to_address(&mut self) -> ::std::vec::Vec<u8> {
self.to_address.take().unwrap_or_else(|| ::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);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronTransferAssetContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.asset_name)?;
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.to_address)?;
},
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);
},
_ => {
::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.asset_name.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(ref v) = self.to_address.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
if let Some(v) = self.amount {
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.asset_name.as_ref() {
os.write_string(1, &v)?;
}
if let Some(ref v) = self.to_address.as_ref() {
os.write_bytes(2, &v)?;
}
if let Some(v) = self.amount {
os.write_uint64(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() -> TronSignTx_TronContract_TronTransferAssetContract {
TronSignTx_TronContract_TronTransferAssetContract::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>(
"asset_name",
|m: &TronSignTx_TronContract_TronTransferAssetContract| { &m.asset_name },
|m: &mut TronSignTx_TronContract_TronTransferAssetContract| { &mut m.asset_name },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"to_address",
|m: &TronSignTx_TronContract_TronTransferAssetContract| { &m.to_address },
|m: &mut TronSignTx_TronContract_TronTransferAssetContract| { &mut m.to_address },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TronSignTx_TronContract_TronTransferAssetContract| { &m.amount },
|m: &mut TronSignTx_TronContract_TronTransferAssetContract| { &mut m.amount },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronTransferAssetContract>(
"TronSignTx.TronContract.TronTransferAssetContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronTransferAssetContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronTransferAssetContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronTransferAssetContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronTransferAssetContract {
fn clear(&mut self) {
self.asset_name.clear();
self.to_address.clear();
self.amount = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronTransferAssetContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronTransferAssetContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronVoteWitnessContract {
pub votes: ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronVoteWitnessContract {
fn default() -> &'a TronSignTx_TronContract_TronVoteWitnessContract {
<TronSignTx_TronContract_TronVoteWitnessContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronVoteWitnessContract {
pub fn new() -> TronSignTx_TronContract_TronVoteWitnessContract {
::std::default::Default::default()
}
pub fn get_votes(&self) -> &[TronSignTx_TronContract_TronVoteWitnessContract_TronVote] {
&self.votes
}
pub fn clear_votes(&mut self) {
self.votes.clear();
}
pub fn set_votes(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>) {
self.votes = v;
}
pub fn mut_votes(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> {
&mut self.votes
}
pub fn take_votes(&mut self) -> ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> {
::std::mem::replace(&mut self.votes, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronVoteWitnessContract {
fn is_initialized(&self) -> bool {
for v in &self.votes {
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.votes)?;
},
_ => {
::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.votes {
let len = value.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<()> {
for v in &self.votes {
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() -> TronSignTx_TronContract_TronVoteWitnessContract {
TronSignTx_TronContract_TronVoteWitnessContract::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<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>>(
"votes",
|m: &TronSignTx_TronContract_TronVoteWitnessContract| { &m.votes },
|m: &mut TronSignTx_TronContract_TronVoteWitnessContract| { &mut m.votes },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronVoteWitnessContract>(
"TronSignTx.TronContract.TronVoteWitnessContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronVoteWitnessContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronVoteWitnessContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronVoteWitnessContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronVoteWitnessContract {
fn clear(&mut self) {
self.votes.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronVoteWitnessContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronVoteWitnessContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
vote_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
vote_count: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
fn default() -> &'a TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
<TronSignTx_TronContract_TronVoteWitnessContract_TronVote as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
pub fn new() -> TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
::std::default::Default::default()
}
pub fn get_vote_address(&self) -> &[u8] {
match self.vote_address.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_vote_address(&mut self) {
self.vote_address.clear();
}
pub fn has_vote_address(&self) -> bool {
self.vote_address.is_some()
}
pub fn set_vote_address(&mut self, v: ::std::vec::Vec<u8>) {
self.vote_address = ::protobuf::SingularField::some(v);
}
pub fn mut_vote_address(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.vote_address.is_none() {
self.vote_address.set_default();
}
self.vote_address.as_mut().unwrap()
}
pub fn take_vote_address(&mut self) -> ::std::vec::Vec<u8> {
self.vote_address.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_vote_count(&self) -> u64 {
self.vote_count.unwrap_or(0)
}
pub fn clear_vote_count(&mut self) {
self.vote_count = ::std::option::Option::None;
}
pub fn has_vote_count(&self) -> bool {
self.vote_count.is_some()
}
pub fn set_vote_count(&mut self, v: u64) {
self.vote_count = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.vote_address)?;
},
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.vote_count = ::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.vote_address.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
if let Some(v) = self.vote_count {
my_size += ::protobuf::rt::value_size(2, 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.vote_address.as_ref() {
os.write_bytes(1, &v)?;
}
if let Some(v) = self.vote_count {
os.write_uint64(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() -> TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
TronSignTx_TronContract_TronVoteWitnessContract_TronVote::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>(
"vote_address",
|m: &TronSignTx_TronContract_TronVoteWitnessContract_TronVote| { &m.vote_address },
|m: &mut TronSignTx_TronContract_TronVoteWitnessContract_TronVote| { &mut m.vote_address },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"vote_count",
|m: &TronSignTx_TronContract_TronVoteWitnessContract_TronVote| { &m.vote_count },
|m: &mut TronSignTx_TronContract_TronVoteWitnessContract_TronVote| { &mut m.vote_count },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>(
"TronSignTx.TronContract.TronVoteWitnessContract.TronVote",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronVoteWitnessContract_TronVote::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
fn clear(&mut self) {
self.vote_address.clear();
self.vote_count = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWitnessCreateContract {
url: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronWitnessCreateContract {
fn default() -> &'a TronSignTx_TronContract_TronWitnessCreateContract {
<TronSignTx_TronContract_TronWitnessCreateContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronWitnessCreateContract {
pub fn new() -> TronSignTx_TronContract_TronWitnessCreateContract {
::std::default::Default::default()
}
pub fn get_url(&self) -> &str {
match self.url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url.clear();
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::protobuf::SingularField::some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url.set_default();
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronWitnessCreateContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.url)?;
},
_ => {
::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.url.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.url.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() -> TronSignTx_TronContract_TronWitnessCreateContract {
TronSignTx_TronContract_TronWitnessCreateContract::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>(
"url",
|m: &TronSignTx_TronContract_TronWitnessCreateContract| { &m.url },
|m: &mut TronSignTx_TronContract_TronWitnessCreateContract| { &mut m.url },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronWitnessCreateContract>(
"TronSignTx.TronContract.TronWitnessCreateContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronWitnessCreateContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronWitnessCreateContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronWitnessCreateContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronWitnessCreateContract {
fn clear(&mut self) {
self.url.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronWitnessCreateContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronWitnessCreateContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWitnessUpdateContract {
update_url: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronWitnessUpdateContract {
fn default() -> &'a TronSignTx_TronContract_TronWitnessUpdateContract {
<TronSignTx_TronContract_TronWitnessUpdateContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronWitnessUpdateContract {
pub fn new() -> TronSignTx_TronContract_TronWitnessUpdateContract {
::std::default::Default::default()
}
pub fn get_update_url(&self) -> &str {
match self.update_url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_update_url(&mut self) {
self.update_url.clear();
}
pub fn has_update_url(&self) -> bool {
self.update_url.is_some()
}
pub fn set_update_url(&mut self, v: ::std::string::String) {
self.update_url = ::protobuf::SingularField::some(v);
}
pub fn mut_update_url(&mut self) -> &mut ::std::string::String {
if self.update_url.is_none() {
self.update_url.set_default();
}
self.update_url.as_mut().unwrap()
}
pub fn take_update_url(&mut self) -> ::std::string::String {
self.update_url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronWitnessUpdateContract {
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 {
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.update_url)?;
},
_ => {
::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.update_url.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.update_url.as_ref() {
os.write_string(2, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TronSignTx_TronContract_TronWitnessUpdateContract {
TronSignTx_TronContract_TronWitnessUpdateContract::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>(
"update_url",
|m: &TronSignTx_TronContract_TronWitnessUpdateContract| { &m.update_url },
|m: &mut TronSignTx_TronContract_TronWitnessUpdateContract| { &mut m.update_url },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronWitnessUpdateContract>(
"TronSignTx.TronContract.TronWitnessUpdateContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronWitnessUpdateContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronWitnessUpdateContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronWitnessUpdateContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronWitnessUpdateContract {
fn clear(&mut self) {
self.update_url.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronWitnessUpdateContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronWitnessUpdateContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAssetIssueContract {
name: ::protobuf::SingularField<::std::string::String>,
abbr: ::protobuf::SingularField<::std::string::String>,
total_supply: ::std::option::Option<u64>,
pub frozen_supply: ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>,
trx_num: ::std::option::Option<u32>,
num: ::std::option::Option<u32>,
start_time: ::std::option::Option<u64>,
end_time: ::std::option::Option<u64>,
description: ::protobuf::SingularField<::std::string::String>,
url: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronAssetIssueContract {
fn default() -> &'a TronSignTx_TronContract_TronAssetIssueContract {
<TronSignTx_TronContract_TronAssetIssueContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronAssetIssueContract {
pub fn new() -> TronSignTx_TronContract_TronAssetIssueContract {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
match self.name.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn has_name(&self) -> bool {
self.name.is_some()
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = ::protobuf::SingularField::some(v);
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
if self.name.is_none() {
self.name.set_default();
}
self.name.as_mut().unwrap()
}
pub fn take_name(&mut self) -> ::std::string::String {
self.name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_abbr(&self) -> &str {
match self.abbr.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_abbr(&mut self) {
self.abbr.clear();
}
pub fn has_abbr(&self) -> bool {
self.abbr.is_some()
}
pub fn set_abbr(&mut self, v: ::std::string::String) {
self.abbr = ::protobuf::SingularField::some(v);
}
pub fn mut_abbr(&mut self) -> &mut ::std::string::String {
if self.abbr.is_none() {
self.abbr.set_default();
}
self.abbr.as_mut().unwrap()
}
pub fn take_abbr(&mut self) -> ::std::string::String {
self.abbr.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_total_supply(&self) -> u64 {
self.total_supply.unwrap_or(0)
}
pub fn clear_total_supply(&mut self) {
self.total_supply = ::std::option::Option::None;
}
pub fn has_total_supply(&self) -> bool {
self.total_supply.is_some()
}
pub fn set_total_supply(&mut self, v: u64) {
self.total_supply = ::std::option::Option::Some(v);
}
pub fn get_frozen_supply(&self) -> &[TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply] {
&self.frozen_supply
}
pub fn clear_frozen_supply(&mut self) {
self.frozen_supply.clear();
}
pub fn set_frozen_supply(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>) {
self.frozen_supply = v;
}
pub fn mut_frozen_supply(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply> {
&mut self.frozen_supply
}
pub fn take_frozen_supply(&mut self) -> ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply> {
::std::mem::replace(&mut self.frozen_supply, ::protobuf::RepeatedField::new())
}
pub fn get_trx_num(&self) -> u32 {
self.trx_num.unwrap_or(0)
}
pub fn clear_trx_num(&mut self) {
self.trx_num = ::std::option::Option::None;
}
pub fn has_trx_num(&self) -> bool {
self.trx_num.is_some()
}
pub fn set_trx_num(&mut self, v: u32) {
self.trx_num = ::std::option::Option::Some(v);
}
pub fn get_num(&self) -> u32 {
self.num.unwrap_or(0)
}
pub fn clear_num(&mut self) {
self.num = ::std::option::Option::None;
}
pub fn has_num(&self) -> bool {
self.num.is_some()
}
pub fn set_num(&mut self, v: u32) {
self.num = ::std::option::Option::Some(v);
}
pub fn get_start_time(&self) -> u64 {
self.start_time.unwrap_or(0)
}
pub fn clear_start_time(&mut self) {
self.start_time = ::std::option::Option::None;
}
pub fn has_start_time(&self) -> bool {
self.start_time.is_some()
}
pub fn set_start_time(&mut self, v: u64) {
self.start_time = ::std::option::Option::Some(v);
}
pub fn get_end_time(&self) -> u64 {
self.end_time.unwrap_or(0)
}
pub fn clear_end_time(&mut self) {
self.end_time = ::std::option::Option::None;
}
pub fn has_end_time(&self) -> bool {
self.end_time.is_some()
}
pub fn set_end_time(&mut self, v: u64) {
self.end_time = ::std::option::Option::Some(v);
}
pub fn get_description(&self) -> &str {
match self.description.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_description(&mut self) {
self.description.clear();
}
pub fn has_description(&self) -> bool {
self.description.is_some()
}
pub fn set_description(&mut self, v: ::std::string::String) {
self.description = ::protobuf::SingularField::some(v);
}
pub fn mut_description(&mut self) -> &mut ::std::string::String {
if self.description.is_none() {
self.description.set_default();
}
self.description.as_mut().unwrap()
}
pub fn take_description(&mut self) -> ::std::string::String {
self.description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_url(&self) -> &str {
match self.url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url.clear();
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::protobuf::SingularField::some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url.set_default();
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronAssetIssueContract {
fn is_initialized(&self) -> bool {
for v in &self.frozen_supply {
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_string_into(wire_type, is, &mut self.name)?;
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.abbr)?;
},
4 => {
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.total_supply = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.frozen_supply)?;
},
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.trx_num = ::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.num = ::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_uint64()?;
self.start_time = ::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_uint64()?;
self.end_time = ::std::option::Option::Some(tmp);
},
10 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.description)?;
},
11 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.url)?;
},
_ => {
::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.name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(ref v) = self.abbr.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.total_supply {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.frozen_supply {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(v) = self.trx_num {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.num {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.start_time {
my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.end_time {
my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.description.as_ref() {
my_size += ::protobuf::rt::string_size(10, &v);
}
if let Some(ref v) = self.url.as_ref() {
my_size += ::protobuf::rt::string_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.name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(ref v) = self.abbr.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.total_supply {
os.write_uint64(4, v)?;
}
for v in &self.frozen_supply {
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.trx_num {
os.write_uint32(6, v)?;
}
if let Some(v) = self.num {
os.write_uint32(7, v)?;
}
if let Some(v) = self.start_time {
os.write_uint64(8, v)?;
}
if let Some(v) = self.end_time {
os.write_uint64(9, v)?;
}
if let Some(ref v) = self.description.as_ref() {
os.write_string(10, &v)?;
}
if let Some(ref v) = self.url.as_ref() {
os.write_string(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() -> TronSignTx_TronContract_TronAssetIssueContract {
TronSignTx_TronContract_TronAssetIssueContract::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>(
"name",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.name },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"abbr",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.abbr },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.abbr },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_supply",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.total_supply },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.total_supply },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>>(
"frozen_supply",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.frozen_supply },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.frozen_supply },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"trx_num",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.trx_num },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.trx_num },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"num",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.num },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.num },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"start_time",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.start_time },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.start_time },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"end_time",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.end_time },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.end_time },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"description",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.description },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.description },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"url",
|m: &TronSignTx_TronContract_TronAssetIssueContract| { &m.url },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract| { &mut m.url },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronAssetIssueContract>(
"TronSignTx.TronContract.TronAssetIssueContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronAssetIssueContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronAssetIssueContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronAssetIssueContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronAssetIssueContract {
fn clear(&mut self) {
self.name.clear();
self.abbr.clear();
self.total_supply = ::std::option::Option::None;
self.frozen_supply.clear();
self.trx_num = ::std::option::Option::None;
self.num = ::std::option::Option::None;
self.start_time = ::std::option::Option::None;
self.end_time = ::std::option::Option::None;
self.description.clear();
self.url.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronAssetIssueContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronAssetIssueContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
frozen_amount: ::std::option::Option<u64>,
frozen_days: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
fn default() -> &'a TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
pub fn new() -> TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
::std::default::Default::default()
}
pub fn get_frozen_amount(&self) -> u64 {
self.frozen_amount.unwrap_or(0)
}
pub fn clear_frozen_amount(&mut self) {
self.frozen_amount = ::std::option::Option::None;
}
pub fn has_frozen_amount(&self) -> bool {
self.frozen_amount.is_some()
}
pub fn set_frozen_amount(&mut self, v: u64) {
self.frozen_amount = ::std::option::Option::Some(v);
}
pub fn get_frozen_days(&self) -> u64 {
self.frozen_days.unwrap_or(0)
}
pub fn clear_frozen_days(&mut self) {
self.frozen_days = ::std::option::Option::None;
}
pub fn has_frozen_days(&self) -> bool {
self.frozen_days.is_some()
}
pub fn set_frozen_days(&mut self, v: u64) {
self.frozen_days = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
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_uint64()?;
self.frozen_amount = ::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_uint64()?;
self.frozen_days = ::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.frozen_amount {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.frozen_days {
my_size += ::protobuf::rt::value_size(2, 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.frozen_amount {
os.write_uint64(1, v)?;
}
if let Some(v) = self.frozen_days {
os.write_uint64(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() -> TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply::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>(
"frozen_amount",
|m: &TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply| { &m.frozen_amount },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply| { &mut m.frozen_amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"frozen_days",
|m: &TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply| { &m.frozen_days },
|m: &mut TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply| { &mut m.frozen_days },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>(
"TronSignTx.TronContract.TronAssetIssueContract.TronFrozenSupply",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
fn clear(&mut self) {
self.frozen_amount = ::std::option::Option::None;
self.frozen_days = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronParticipateAssetIssueContract {
to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
asset_name: ::protobuf::SingularField<::std::string::String>,
amount: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronParticipateAssetIssueContract {
fn default() -> &'a TronSignTx_TronContract_TronParticipateAssetIssueContract {
<TronSignTx_TronContract_TronParticipateAssetIssueContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronParticipateAssetIssueContract {
pub fn new() -> TronSignTx_TronContract_TronParticipateAssetIssueContract {
::std::default::Default::default()
}
pub fn get_to_address(&self) -> &[u8] {
match self.to_address.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_to_address(&mut self) {
self.to_address.clear();
}
pub fn has_to_address(&self) -> bool {
self.to_address.is_some()
}
pub fn set_to_address(&mut self, v: ::std::vec::Vec<u8>) {
self.to_address = ::protobuf::SingularField::some(v);
}
pub fn mut_to_address(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.to_address.is_none() {
self.to_address.set_default();
}
self.to_address.as_mut().unwrap()
}
pub fn take_to_address(&mut self) -> ::std::vec::Vec<u8> {
self.to_address.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn get_asset_name(&self) -> &str {
match self.asset_name.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_asset_name(&mut self) {
self.asset_name.clear();
}
pub fn has_asset_name(&self) -> bool {
self.asset_name.is_some()
}
pub fn set_asset_name(&mut self, v: ::std::string::String) {
self.asset_name = ::protobuf::SingularField::some(v);
}
pub fn mut_asset_name(&mut self) -> &mut ::std::string::String {
if self.asset_name.is_none() {
self.asset_name.set_default();
}
self.asset_name.as_mut().unwrap()
}
pub fn take_asset_name(&mut self) -> ::std::string::String {
self.asset_name.take().unwrap_or_else(|| ::std::string::String::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);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronParticipateAssetIssueContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.to_address)?;
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.asset_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_uint64()?;
self.amount = ::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.to_address.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
if let Some(ref v) = self.asset_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.amount {
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.to_address.as_ref() {
os.write_bytes(1, &v)?;
}
if let Some(ref v) = self.asset_name.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.amount {
os.write_uint64(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() -> TronSignTx_TronContract_TronParticipateAssetIssueContract {
TronSignTx_TronContract_TronParticipateAssetIssueContract::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>(
"to_address",
|m: &TronSignTx_TronContract_TronParticipateAssetIssueContract| { &m.to_address },
|m: &mut TronSignTx_TronContract_TronParticipateAssetIssueContract| { &mut m.to_address },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"asset_name",
|m: &TronSignTx_TronContract_TronParticipateAssetIssueContract| { &m.asset_name },
|m: &mut TronSignTx_TronContract_TronParticipateAssetIssueContract| { &mut m.asset_name },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"amount",
|m: &TronSignTx_TronContract_TronParticipateAssetIssueContract| { &m.amount },
|m: &mut TronSignTx_TronContract_TronParticipateAssetIssueContract| { &mut m.amount },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronParticipateAssetIssueContract>(
"TronSignTx.TronContract.TronParticipateAssetIssueContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronParticipateAssetIssueContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronParticipateAssetIssueContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronParticipateAssetIssueContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronParticipateAssetIssueContract {
fn clear(&mut self) {
self.to_address.clear();
self.asset_name.clear();
self.amount = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronParticipateAssetIssueContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronParticipateAssetIssueContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronFreezeBalanceContract {
frozen_balance: ::std::option::Option<u64>,
frozen_duration: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronFreezeBalanceContract {
fn default() -> &'a TronSignTx_TronContract_TronFreezeBalanceContract {
<TronSignTx_TronContract_TronFreezeBalanceContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronFreezeBalanceContract {
pub fn new() -> TronSignTx_TronContract_TronFreezeBalanceContract {
::std::default::Default::default()
}
pub fn get_frozen_balance(&self) -> u64 {
self.frozen_balance.unwrap_or(0)
}
pub fn clear_frozen_balance(&mut self) {
self.frozen_balance = ::std::option::Option::None;
}
pub fn has_frozen_balance(&self) -> bool {
self.frozen_balance.is_some()
}
pub fn set_frozen_balance(&mut self, v: u64) {
self.frozen_balance = ::std::option::Option::Some(v);
}
pub fn get_frozen_duration(&self) -> u64 {
self.frozen_duration.unwrap_or(0)
}
pub fn clear_frozen_duration(&mut self) {
self.frozen_duration = ::std::option::Option::None;
}
pub fn has_frozen_duration(&self) -> bool {
self.frozen_duration.is_some()
}
pub fn set_frozen_duration(&mut self, v: u64) {
self.frozen_duration = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronFreezeBalanceContract {
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_uint64()?;
self.frozen_balance = ::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_uint64()?;
self.frozen_duration = ::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.frozen_balance {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.frozen_duration {
my_size += ::protobuf::rt::value_size(2, 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.frozen_balance {
os.write_uint64(1, v)?;
}
if let Some(v) = self.frozen_duration {
os.write_uint64(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() -> TronSignTx_TronContract_TronFreezeBalanceContract {
TronSignTx_TronContract_TronFreezeBalanceContract::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>(
"frozen_balance",
|m: &TronSignTx_TronContract_TronFreezeBalanceContract| { &m.frozen_balance },
|m: &mut TronSignTx_TronContract_TronFreezeBalanceContract| { &mut m.frozen_balance },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"frozen_duration",
|m: &TronSignTx_TronContract_TronFreezeBalanceContract| { &m.frozen_duration },
|m: &mut TronSignTx_TronContract_TronFreezeBalanceContract| { &mut m.frozen_duration },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronFreezeBalanceContract>(
"TronSignTx.TronContract.TronFreezeBalanceContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronFreezeBalanceContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronFreezeBalanceContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronFreezeBalanceContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronFreezeBalanceContract {
fn clear(&mut self) {
self.frozen_balance = ::std::option::Option::None;
self.frozen_duration = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronFreezeBalanceContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronFreezeBalanceContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUnfreezeBalanceContract {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronUnfreezeBalanceContract {
fn default() -> &'a TronSignTx_TronContract_TronUnfreezeBalanceContract {
<TronSignTx_TronContract_TronUnfreezeBalanceContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronUnfreezeBalanceContract {
pub fn new() -> TronSignTx_TronContract_TronUnfreezeBalanceContract {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronUnfreezeBalanceContract {
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 {
_ => {
::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;
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<()> {
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() -> TronSignTx_TronContract_TronUnfreezeBalanceContract {
TronSignTx_TronContract_TronUnfreezeBalanceContract::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronUnfreezeBalanceContract>(
"TronSignTx.TronContract.TronUnfreezeBalanceContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronUnfreezeBalanceContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronUnfreezeBalanceContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronUnfreezeBalanceContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronUnfreezeBalanceContract {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronUnfreezeBalanceContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronUnfreezeBalanceContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUnfreezeAssetContract {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronUnfreezeAssetContract {
fn default() -> &'a TronSignTx_TronContract_TronUnfreezeAssetContract {
<TronSignTx_TronContract_TronUnfreezeAssetContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronUnfreezeAssetContract {
pub fn new() -> TronSignTx_TronContract_TronUnfreezeAssetContract {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronUnfreezeAssetContract {
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 {
_ => {
::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;
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<()> {
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() -> TronSignTx_TronContract_TronUnfreezeAssetContract {
TronSignTx_TronContract_TronUnfreezeAssetContract::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronUnfreezeAssetContract>(
"TronSignTx.TronContract.TronUnfreezeAssetContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronUnfreezeAssetContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronUnfreezeAssetContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronUnfreezeAssetContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronUnfreezeAssetContract {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronUnfreezeAssetContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronUnfreezeAssetContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWithdrawBalanceContract {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronWithdrawBalanceContract {
fn default() -> &'a TronSignTx_TronContract_TronWithdrawBalanceContract {
<TronSignTx_TronContract_TronWithdrawBalanceContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronWithdrawBalanceContract {
pub fn new() -> TronSignTx_TronContract_TronWithdrawBalanceContract {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronWithdrawBalanceContract {
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 {
_ => {
::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;
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<()> {
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() -> TronSignTx_TronContract_TronWithdrawBalanceContract {
TronSignTx_TronContract_TronWithdrawBalanceContract::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronWithdrawBalanceContract>(
"TronSignTx.TronContract.TronWithdrawBalanceContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronWithdrawBalanceContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronWithdrawBalanceContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronWithdrawBalanceContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronWithdrawBalanceContract {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronWithdrawBalanceContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronWithdrawBalanceContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUpdateAssetContract {
description: ::protobuf::SingularField<::std::string::String>,
url: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronUpdateAssetContract {
fn default() -> &'a TronSignTx_TronContract_TronUpdateAssetContract {
<TronSignTx_TronContract_TronUpdateAssetContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronUpdateAssetContract {
pub fn new() -> TronSignTx_TronContract_TronUpdateAssetContract {
::std::default::Default::default()
}
pub fn get_description(&self) -> &str {
match self.description.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_description(&mut self) {
self.description.clear();
}
pub fn has_description(&self) -> bool {
self.description.is_some()
}
pub fn set_description(&mut self, v: ::std::string::String) {
self.description = ::protobuf::SingularField::some(v);
}
pub fn mut_description(&mut self) -> &mut ::std::string::String {
if self.description.is_none() {
self.description.set_default();
}
self.description.as_mut().unwrap()
}
pub fn take_description(&mut self) -> ::std::string::String {
self.description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_url(&self) -> &str {
match self.url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url.clear();
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::protobuf::SingularField::some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url.set_default();
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronUpdateAssetContract {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.description)?;
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.url)?;
},
_ => {
::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.description.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(ref v) = self.url.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.description.as_ref() {
os.write_string(1, &v)?;
}
if let Some(ref v) = self.url.as_ref() {
os.write_string(2, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TronSignTx_TronContract_TronUpdateAssetContract {
TronSignTx_TronContract_TronUpdateAssetContract::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>(
"description",
|m: &TronSignTx_TronContract_TronUpdateAssetContract| { &m.description },
|m: &mut TronSignTx_TronContract_TronUpdateAssetContract| { &mut m.description },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"url",
|m: &TronSignTx_TronContract_TronUpdateAssetContract| { &m.url },
|m: &mut TronSignTx_TronContract_TronUpdateAssetContract| { &mut m.url },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronUpdateAssetContract>(
"TronSignTx.TronContract.TronUpdateAssetContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronUpdateAssetContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronUpdateAssetContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronUpdateAssetContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronUpdateAssetContract {
fn clear(&mut self) {
self.description.clear();
self.url.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronUpdateAssetContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronUpdateAssetContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalCreateContract {
pub parameters: ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronProposalCreateContract {
fn default() -> &'a TronSignTx_TronContract_TronProposalCreateContract {
<TronSignTx_TronContract_TronProposalCreateContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronProposalCreateContract {
pub fn new() -> TronSignTx_TronContract_TronProposalCreateContract {
::std::default::Default::default()
}
pub fn get_parameters(&self) -> &[TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters] {
&self.parameters
}
pub fn clear_parameters(&mut self) {
self.parameters.clear();
}
pub fn set_parameters(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>) {
self.parameters = v;
}
pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> {
&mut self.parameters
}
pub fn take_parameters(&mut self) -> ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> {
::std::mem::replace(&mut self.parameters, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronProposalCreateContract {
fn is_initialized(&self) -> bool {
for v in &self.parameters {
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.parameters)?;
},
_ => {
::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.parameters {
let len = value.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<()> {
for v in &self.parameters {
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() -> TronSignTx_TronContract_TronProposalCreateContract {
TronSignTx_TronContract_TronProposalCreateContract::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<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>>(
"parameters",
|m: &TronSignTx_TronContract_TronProposalCreateContract| { &m.parameters },
|m: &mut TronSignTx_TronContract_TronProposalCreateContract| { &mut m.parameters },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronProposalCreateContract>(
"TronSignTx.TronContract.TronProposalCreateContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronProposalCreateContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronProposalCreateContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronProposalCreateContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalCreateContract {
fn clear(&mut self) {
self.parameters.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronProposalCreateContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronProposalCreateContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
key: ::std::option::Option<u64>,
value: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
fn default() -> &'a TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
pub fn new() -> TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
::std::default::Default::default()
}
pub fn get_key(&self) -> u64 {
self.key.unwrap_or(0)
}
pub fn clear_key(&mut self) {
self.key = ::std::option::Option::None;
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn set_key(&mut self, v: u64) {
self.key = ::std::option::Option::Some(v);
}
pub fn get_value(&self) -> u64 {
self.value.unwrap_or(0)
}
pub fn clear_value(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: u64) {
self.value = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
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_uint64()?;
self.key = ::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_uint64()?;
self.value = ::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.key {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.value {
my_size += ::protobuf::rt::value_size(2, 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.key {
os.write_uint64(1, v)?;
}
if let Some(v) = self.value {
os.write_uint64(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() -> TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters::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>(
"key",
|m: &TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters| { &m.key },
|m: &mut TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters| { &mut m.key },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"value",
|m: &TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters| { &m.value },
|m: &mut TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>(
"TronSignTx.TronContract.TronProposalCreateContract.TronProposalParameters",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
fn clear(&mut self) {
self.key = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalApproveContract {
proposal_id: ::std::option::Option<u64>,
is_add_approval: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronProposalApproveContract {
fn default() -> &'a TronSignTx_TronContract_TronProposalApproveContract {
<TronSignTx_TronContract_TronProposalApproveContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronProposalApproveContract {
pub fn new() -> TronSignTx_TronContract_TronProposalApproveContract {
::std::default::Default::default()
}
pub fn get_proposal_id(&self) -> u64 {
self.proposal_id.unwrap_or(0)
}
pub fn clear_proposal_id(&mut self) {
self.proposal_id = ::std::option::Option::None;
}
pub fn has_proposal_id(&self) -> bool {
self.proposal_id.is_some()
}
pub fn set_proposal_id(&mut self, v: u64) {
self.proposal_id = ::std::option::Option::Some(v);
}
pub fn get_is_add_approval(&self) -> bool {
self.is_add_approval.unwrap_or(false)
}
pub fn clear_is_add_approval(&mut self) {
self.is_add_approval = ::std::option::Option::None;
}
pub fn has_is_add_approval(&self) -> bool {
self.is_add_approval.is_some()
}
pub fn set_is_add_approval(&mut self, v: bool) {
self.is_add_approval = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronProposalApproveContract {
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_uint64()?;
self.proposal_id = ::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_bool()?;
self.is_add_approval = ::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.proposal_id {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.is_add_approval {
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.proposal_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.is_add_approval {
os.write_bool(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() -> TronSignTx_TronContract_TronProposalApproveContract {
TronSignTx_TronContract_TronProposalApproveContract::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>(
"proposal_id",
|m: &TronSignTx_TronContract_TronProposalApproveContract| { &m.proposal_id },
|m: &mut TronSignTx_TronContract_TronProposalApproveContract| { &mut m.proposal_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"is_add_approval",
|m: &TronSignTx_TronContract_TronProposalApproveContract| { &m.is_add_approval },
|m: &mut TronSignTx_TronContract_TronProposalApproveContract| { &mut m.is_add_approval },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronProposalApproveContract>(
"TronSignTx.TronContract.TronProposalApproveContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronProposalApproveContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronProposalApproveContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronProposalApproveContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalApproveContract {
fn clear(&mut self) {
self.proposal_id = ::std::option::Option::None;
self.is_add_approval = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronProposalApproveContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronProposalApproveContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalDeleteContract {
proposal_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TronSignTx_TronContract_TronProposalDeleteContract {
fn default() -> &'a TronSignTx_TronContract_TronProposalDeleteContract {
<TronSignTx_TronContract_TronProposalDeleteContract as ::protobuf::Message>::default_instance()
}
}
impl TronSignTx_TronContract_TronProposalDeleteContract {
pub fn new() -> TronSignTx_TronContract_TronProposalDeleteContract {
::std::default::Default::default()
}
pub fn get_proposal_id(&self) -> u64 {
self.proposal_id.unwrap_or(0)
}
pub fn clear_proposal_id(&mut self) {
self.proposal_id = ::std::option::Option::None;
}
pub fn has_proposal_id(&self) -> bool {
self.proposal_id.is_some()
}
pub fn set_proposal_id(&mut self, v: u64) {
self.proposal_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for TronSignTx_TronContract_TronProposalDeleteContract {
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_uint64()?;
self.proposal_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.proposal_id {
my_size += ::protobuf::rt::value_size(1, 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.proposal_id {
os.write_uint64(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() -> TronSignTx_TronContract_TronProposalDeleteContract {
TronSignTx_TronContract_TronProposalDeleteContract::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>(
"proposal_id",
|m: &TronSignTx_TronContract_TronProposalDeleteContract| { &m.proposal_id },
|m: &mut TronSignTx_TronContract_TronProposalDeleteContract| { &mut m.proposal_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignTx_TronContract_TronProposalDeleteContract>(
"TronSignTx.TronContract.TronProposalDeleteContract",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignTx_TronContract_TronProposalDeleteContract {
static instance: ::protobuf::rt::LazyV2<TronSignTx_TronContract_TronProposalDeleteContract> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignTx_TronContract_TronProposalDeleteContract::new)
}
}
impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalDeleteContract {
fn clear(&mut self) {
self.proposal_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignTx_TronContract_TronProposalDeleteContract {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignTx_TronContract_TronProposalDeleteContract {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TronSignedTx {
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 TronSignedTx {
fn default() -> &'a TronSignedTx {
<TronSignedTx as ::protobuf::Message>::default_instance()
}
}
impl TronSignedTx {
pub fn new() -> TronSignedTx {
::std::default::Default::default()
}
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 TronSignedTx {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
},
2 => {
::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(ref v) = self.signature.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
if let Some(ref v) = self.serialized_tx.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.signature.as_ref() {
os.write_bytes(1, &v)?;
}
if let Some(ref v) = self.serialized_tx.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() -> TronSignedTx {
TronSignedTx::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"signature",
|m: &TronSignedTx| { &m.signature },
|m: &mut TronSignedTx| { &mut m.signature },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"serialized_tx",
|m: &TronSignedTx| { &m.serialized_tx },
|m: &mut TronSignedTx| { &mut m.serialized_tx },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TronSignedTx>(
"TronSignedTx",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static TronSignedTx {
static instance: ::protobuf::rt::LazyV2<TronSignedTx> = ::protobuf::rt::LazyV2::INIT;
instance.get(TronSignedTx::new)
}
}
impl ::protobuf::Clear for TronSignedTx {
fn clear(&mut self) {
self.signature.clear();
self.serialized_tx.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TronSignedTx {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TronSignedTx {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x13messages-tron.proto\"P\n\x0eTronGetAddress\x12\x1b\n\taddress_n\
\x18\x01\x20\x03(\rR\x08addressN\x12!\n\x0cshow_display\x18\x02\x20\x01(\
\x08R\x0bshowDisplay\"'\n\x0bTronAddress\x12\x18\n\x07address\x18\x01\
\x20\x01(\tR\x07address\"\xcb\x1d\n\nTronSignTx\x12\x1b\n\taddress_n\x18\
\x01\x20\x03(\rR\x08addressN\x12&\n\x0fref_block_bytes\x18\x02\x20\x01(\
\x0cR\rrefBlockBytes\x12$\n\x0eref_block_hash\x18\x03\x20\x01(\x0cR\x0cr\
efBlockHash\x12\x1e\n\nexpiration\x18\x04\x20\x01(\x04R\nexpiration\x12\
\x12\n\x04data\x18\x05\x20\x01(\tR\x04data\x124\n\x08contract\x18\x06\
\x20\x01(\x0b2\x18.TronSignTx.TronContractR\x08contract\x12\x1c\n\ttimes\
tamp\x18\x07\x20\x01(\x04R\ttimestamp\x1a\xc9\x1b\n\x0cTronContract\x12Z\
\n\x11transfer_contract\x18\x01\x20\x01(\x0b2-.TronSignTx.TronContract.T\
ronTransferContractR\x10transferContract\x12j\n\x17transfer_asset_contra\
ct\x18\x02\x20\x01(\x0b22.TronSignTx.TronContract.TronTransferAssetContr\
actR\x15transferAssetContract\x12d\n\x15vote_witness_contract\x18\x04\
\x20\x01(\x0b20.TronSignTx.TronContract.TronVoteWitnessContractR\x13vote\
WitnessContract\x12j\n\x17witness_create_contract\x18\x05\x20\x01(\x0b22\
.TronSignTx.TronContract.TronWitnessCreateContractR\x15witnessCreateCont\
ract\x12a\n\x14asset_issue_contract\x18\x06\x20\x01(\x0b2/.TronSignTx.Tr\
onContract.TronAssetIssueContractR\x12assetIssueContract\x12j\n\x17witne\
ss_update_contract\x18\x08\x20\x01(\x0b22.TronSignTx.TronContract.TronWi\
tnessUpdateContractR\x15witnessUpdateContract\x12\x83\x01\n\x20participa\
te_asset_issue_contract\x18\t\x20\x01(\x0b2:.TronSignTx.TronContract.Tro\
nParticipateAssetIssueContractR\x1dparticipateAssetIssueContract\x12j\n\
\x17account_update_contract\x18\n\x20\x01(\x0b22.TronSignTx.TronContract\
.TronAccountUpdateContractR\x15accountUpdateContract\x12j\n\x17freeze_ba\
lance_contract\x18\x0b\x20\x01(\x0b22.TronSignTx.TronContract.TronFreeze\
BalanceContractR\x15freezeBalanceContract\x12p\n\x19unfreeze_balance_con\
tract\x18\x0c\x20\x01(\x0b24.TronSignTx.TronContract.TronUnfreezeBalance\
ContractR\x17unfreezeBalanceContract\x12p\n\x19withdraw_balance_contract\
\x18\r\x20\x01(\x0b24.TronSignTx.TronContract.TronWithdrawBalanceContrac\
tR\x17withdrawBalanceContract\x12j\n\x17unfreeze_asset_contract\x18\x0e\
\x20\x01(\x0b22.TronSignTx.TronContract.TronUnfreezeAssetContractR\x15un\
freezeAssetContract\x12d\n\x15update_asset_contract\x18\x0f\x20\x01(\x0b\
20.TronSignTx.TronContract.TronUpdateAssetContractR\x13updateAssetContra\
ct\x12m\n\x18proposal_create_contract\x18\x10\x20\x01(\x0b23.TronSignTx.\
TronContract.TronProposalCreateContractR\x16proposalCreateContract\x12p\
\n\x19proposal_approve_contract\x18\x11\x20\x01(\x0b24.TronSignTx.TronCo\
ntract.TronProposalApproveContractR\x17proposalApproveContract\x12m\n\
\x18proposal_delete_contract\x18\x12\x20\x01(\x0b23.TronSignTx.TronContr\
act.TronProposalDeleteContractR\x16proposalDeleteContract\x1a>\n\x19Tron\
AccountUpdateContract\x12!\n\x0caccount_name\x18\x01\x20\x01(\tR\x0bacco\
untName\x1aM\n\x14TronTransferContract\x12\x1d\n\nto_address\x18\x01\x20\
\x01(\x0cR\ttoAddress\x12\x16\n\x06amount\x18\x02\x20\x01(\x04R\x06amoun\
t\x1aq\n\x19TronTransferAssetContract\x12\x1d\n\nasset_name\x18\x01\x20\
\x01(\tR\tassetName\x12\x1d\n\nto_address\x18\x02\x20\x01(\x0cR\ttoAddre\
ss\x12\x16\n\x06amount\x18\x03\x20\x01(\x04R\x06amount\x1a\xb8\x01\n\x17\
TronVoteWitnessContract\x12O\n\x05votes\x18\x01\x20\x03(\x0b29.TronSignT\
x.TronContract.TronVoteWitnessContract.TronVoteR\x05votes\x1aL\n\x08Tron\
Vote\x12!\n\x0cvote_address\x18\x01\x20\x01(\x0cR\x0bvoteAddress\x12\x1d\
\n\nvote_count\x18\x02\x20\x01(\x04R\tvoteCount\x1a-\n\x19TronWitnessCre\
ateContract\x12\x10\n\x03url\x18\x01\x20\x01(\tR\x03url\x1a:\n\x19TronWi\
tnessUpdateContract\x12\x1d\n\nupdate_url\x18\x02\x20\x01(\tR\tupdateUrl\
\x1a\xbd\x03\n\x16TronAssetIssueContract\x12\x12\n\x04name\x18\x02\x20\
\x01(\tR\x04name\x12\x12\n\x04abbr\x18\x03\x20\x01(\tR\x04abbr\x12!\n\
\x0ctotal_supply\x18\x04\x20\x01(\x04R\x0btotalSupply\x12e\n\rfrozen_sup\
ply\x18\x05\x20\x03(\x0b2@.TronSignTx.TronContract.TronAssetIssueContrac\
t.TronFrozenSupplyR\x0cfrozenSupply\x12\x17\n\x07trx_num\x18\x06\x20\x01\
(\rR\x06trxNum\x12\x10\n\x03num\x18\x07\x20\x01(\rR\x03num\x12\x1d\n\nst\
art_time\x18\x08\x20\x01(\x04R\tstartTime\x12\x19\n\x08end_time\x18\t\
\x20\x01(\x04R\x07endTime\x12\x20\n\x0bdescription\x18\n\x20\x01(\tR\x0b\
description\x12\x10\n\x03url\x18\x0b\x20\x01(\tR\x03url\x1aX\n\x10TronFr\
ozenSupply\x12#\n\rfrozen_amount\x18\x01\x20\x01(\x04R\x0cfrozenAmount\
\x12\x1f\n\x0bfrozen_days\x18\x02\x20\x01(\x04R\nfrozenDays\x1ay\n!TronP\
articipateAssetIssueContract\x12\x1d\n\nto_address\x18\x01\x20\x01(\x0cR\
\ttoAddress\x12\x1d\n\nasset_name\x18\x02\x20\x01(\tR\tassetName\x12\x16\
\n\x06amount\x18\x03\x20\x01(\x04R\x06amount\x1ak\n\x19TronFreezeBalance\
Contract\x12%\n\x0efrozen_balance\x18\x01\x20\x01(\x04R\rfrozenBalance\
\x12'\n\x0ffrozen_duration\x18\x02\x20\x01(\x04R\x0efrozenDuration\x1a\
\x1d\n\x1bTronUnfreezeBalanceContract\x1a\x1b\n\x19TronUnfreezeAssetCont\
ract\x1a\x1d\n\x1bTronWithdrawBalanceContract\x1aM\n\x17TronUpdateAssetC\
ontract\x12\x20\n\x0bdescription\x18\x01\x20\x01(\tR\x0bdescription\x12\
\x10\n\x03url\x18\x02\x20\x01(\tR\x03url\x1a\xca\x01\n\x1aTronProposalCr\
eateContract\x12j\n\nparameters\x18\x01\x20\x03(\x0b2J.TronSignTx.TronCo\
ntract.TronProposalCreateContract.TronProposalParametersR\nparameters\
\x1a@\n\x16TronProposalParameters\x12\x10\n\x03key\x18\x01\x20\x01(\x04R\
\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x04R\x05value\x1af\n\x1bTron\
ProposalApproveContract\x12\x1f\n\x0bproposal_id\x18\x01\x20\x01(\x04R\n\
proposalId\x12&\n\x0fis_add_approval\x18\x02\x20\x01(\x08R\risAddApprova\
l\x1a=\n\x1aTronProposalDeleteContract\x12\x1f\n\x0bproposal_id\x18\x01\
\x20\x01(\x04R\nproposalId\"Q\n\x0cTronSignedTx\x12\x1c\n\tsignature\x18\
\x01\x20\x01(\x0cR\tsignature\x12#\n\rserialized_tx\x18\x02\x20\x01(\x0c\
R\x0cserializedTxB8\n#com.satoshilabs.trezor.lib.protobufB\x11TrezorMess\
ageTronJ\x8eA\n\x07\x12\x05\0\0\xa1\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\
\x12\n\x08\n\x01\x08\x12\x03\x03\0<\n.\n\x02\x08\x01\x12\x03\x03\0<\x1a#\
\x20Sugar\x20for\x20easier\x20handling\x20in\x20Java\n\n\x08\n\x01\x08\
\x12\x03\x04\02\n\t\n\x02\x08\x08\x12\x03\x04\02\n\x90\x01\n\x02\x04\0\
\x12\x04\x0c\0\x0f\x01\x1a\x83\x01*\n\x20Request:\x20Ask\x20device\x20fo\
r\x20Tron\x20address\x20corresponding\x20to\x20address_n\x20path\n\x20@n\
ext\x20PassphraseRequest\n\x20@next\x20TronAddress\n\x20@next\x20Failure\
\n\n\n\n\x03\x04\0\x01\x12\x03\x0c\x08\x16\n=\n\x04\x04\0\x02\0\x12\x03\
\r\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20key\x20from\x20m\
aster\x20node\n\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\r\x04\x0c\n\x0c\n\
\x05\x04\0\x02\0\x05\x12\x03\r\r\x13\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\
\r\x14\x1d\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\r\x20!\nC\n\x04\x04\0\x02\
\x01\x12\x03\x0e\x04#\"6\x20Optionally\x20show\x20on\x20display\x20befor\
e\x20sending\x20the\x20result\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\
\x0e\x04\x0c\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x0e\r\x11\n\x0c\n\x05\
\x04\0\x02\x01\x01\x12\x03\x0e\x12\x1e\n\x0c\n\x05\x04\0\x02\x01\x03\x12\
\x03\x0e!\"\nf\n\x02\x04\x01\x12\x04\x15\0\x17\x01\x1aZ*\n\x20Response:\
\x20Contains\x20Tron\x20address\x20derived\x20from\x20device\x20private\
\x20seed\n\x20@prev\x20TronGetAddress\n\n\n\n\x03\x04\x01\x01\x12\x03\
\x15\x08\x13\n$\n\x04\x04\x01\x02\0\x12\x03\x16\x04\x20\"\x17\x20Tron\
\x20address\x20(base58)\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x16\x04\
\x0c\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\x16\r\x13\n\x0c\n\x05\x04\x01\
\x02\0\x01\x12\x03\x16\x14\x1b\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x16\
\x1e\x1f\nQ\n\x02\x04\x02\x12\x05\x1d\0\x98\x01\x01\x1aD*\n\x20Request:\
\x20Ask\x20device\x20to\x20sign\x20Tron\x20transaction\n\x20@next\x20Tro\
nSignedTx\n\n\n\n\x03\x04\x02\x01\x12\x03\x1d\x08\x12\n=\n\x04\x04\x02\
\x02\0\x12\x03\x1e\x04\"\"0\x20BIP-32\x20path\x20to\x20derive\x20the\x20\
key\x20from\x20master\x20node\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\
\x1e\x04\x0c\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x1e\r\x13\n\x0c\n\x05\
\x04\x02\x02\0\x01\x12\x03\x1e\x14\x1d\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
\x03\x1e\x20!\nD\n\x04\x04\x02\x02\x01\x12\x03\x20\x04'\x1a\x1c\x20Commo\
n\x20part\x20of\x20transaction\n\"\x19\x20Reference\x20block\x20number\
\x20\n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\x20\x04\x0c\n\x0c\n\x05\
\x04\x02\x02\x01\x05\x12\x03\x20\r\x12\n\x0c\n\x05\x04\x02\x02\x01\x01\
\x12\x03\x20\x13\"\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x20%&\n#\n\
\x04\x04\x02\x02\x02\x12\x03!\x04&\"\x16\x20Reference\x20block\x20hash\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\x12\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03!\x13\
!\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03!$%\n%\n\x04\x04\x02\x02\x03\
\x12\x03\"\x04#\"\x18\x20Transaction\x20expiration\n\n\x0c\n\x05\x04\x02\
\x02\x03\x04\x12\x03\"\x04\x0c\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03\"\
\r\x13\n\x0c\n\x05\x04\x02\x02\x03\x01\x12\x03\"\x14\x1e\n\x0c\n\x05\x04\
\x02\x02\x03\x03\x12\x03\"!\"\n%\n\x04\x04\x02\x02\x04\x12\x03#\x04\x1d\
\"\x18\x20Extra\x20transaction\x20info\n\n\x0c\n\x05\x04\x02\x02\x04\x04\
\x12\x03#\x04\x0c\n\x0c\n\x05\x04\x02\x02\x04\x05\x12\x03#\r\x13\n\x0c\n\
\x05\x04\x02\x02\x04\x01\x12\x03#\x14\x18\n\x0c\n\x05\x04\x02\x02\x04\
\x03\x12\x03#\x1b\x1c\n\x20\n\x04\x04\x02\x02\x05\x12\x03$\x04'\"\x13\
\x20Contract\x20messages\n\n\x0c\n\x05\x04\x02\x02\x05\x04\x12\x03$\x04\
\x0c\n\x0c\n\x05\x04\x02\x02\x05\x06\x12\x03$\r\x19\n\x0c\n\x05\x04\x02\
\x02\x05\x01\x12\x03$\x1a\"\n\x0c\n\x05\x04\x02\x02\x05\x03\x12\x03$%&\n\
\x1c\n\x04\x04\x02\x02\x06\x12\x03%\x04\"\"\x0f\x20UTC\x20timestamp\n\n\
\x0c\n\x05\x04\x02\x02\x06\x04\x12\x03%\x04\x0c\n\x0c\n\x05\x04\x02\x02\
\x06\x05\x12\x03%\r\x13\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x03%\x14\x1d\
\n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x03%\x20!\n,\n\x04\x04\x02\x03\0\
\x12\x05+\x04\x97\x01\x05\x1a\x1d**\n\x20Tron\x20Contracts\x20Messages\n\
\n\n\x0c\n\x05\x04\x02\x03\0\x01\x12\x03+\x0c\x18\n%\n\x06\x04\x02\x03\0\
\x03\0\x12\x04-\x08/\t\x1a\x15\x20Update\x20account\x20name\n\n\x0e\n\
\x07\x04\x02\x03\0\x03\0\x01\x12\x03-\x10)\n-\n\x08\x04\x02\x03\0\x03\0\
\x02\0\x12\x03.\x0c-\"\x1c\x20Account\x20name\x20is\x20not\x20unique\n\n\
\x10\n\t\x04\x02\x03\0\x03\0\x02\0\x04\x12\x03.\x0c\x14\n\x10\n\t\x04\
\x02\x03\0\x03\0\x02\0\x05\x12\x03.\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\
\0\x02\0\x01\x12\x03.\x1c(\n\x10\n\t\x04\x02\x03\0\x03\0\x02\0\x03\x12\
\x03.+,\n\x1e\n\x06\x04\x02\x03\0\x03\x01\x12\x041\x084\t\x1a\x0e\x20Tra\
nsfer\x20TRX\n\n\x0e\n\x07\x04\x02\x03\0\x03\x01\x01\x12\x031\x10$\n/\n\
\x08\x04\x02\x03\0\x03\x01\x02\0\x12\x032\x0c*\"\x1e\x20To\x20address\
\x20-\x20decoded\x20base\x2058\n\n\x10\n\t\x04\x02\x03\0\x03\x01\x02\0\
\x04\x12\x032\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x01\x02\0\x05\x12\x032\
\x15\x1a\n\x10\n\t\x04\x02\x03\0\x03\x01\x02\0\x01\x12\x032\x1b%\n\x10\n\
\t\x04\x02\x03\0\x03\x01\x02\0\x03\x12\x032()\n,\n\x08\x04\x02\x03\0\x03\
\x01\x02\x01\x12\x033\x0c'\"\x1b\x20TRX\x20amount\x20in\x20sun\x20(10^-6\
)\n\n\x10\n\t\x04\x02\x03\0\x03\x01\x02\x01\x04\x12\x033\x0c\x14\n\x10\n\
\t\x04\x02\x03\0\x03\x01\x02\x01\x05\x12\x033\x15\x1b\n\x10\n\t\x04\x02\
\x03\0\x03\x01\x02\x01\x01\x12\x033\x1c\"\n\x10\n\t\x04\x02\x03\0\x03\
\x01\x02\x01\x03\x12\x033%&\n\x20\n\x06\x04\x02\x03\0\x03\x02\x12\x046\
\x08:\t\x1a\x10\x20Transfer\x20asset\n\n\x0e\n\x07\x04\x02\x03\0\x03\x02\
\x01\x12\x036\x10)\n\x1d\n\x08\x04\x02\x03\0\x03\x02\x02\0\x12\x037\x0c+\
\"\x0c\x20Asset\x20name\n\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\0\x04\x12\
\x037\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\0\x05\x12\x037\x15\x1b\
\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\0\x01\x12\x037\x1c&\n\x10\n\t\x04\
\x02\x03\0\x03\x02\x02\0\x03\x12\x037)*\n/\n\x08\x04\x02\x03\0\x03\x02\
\x02\x01\x12\x038\x0c*\"\x1e\x20To\x20address\x20-\x20decoded\x20base\
\x2058\n\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\x01\x04\x12\x038\x0c\x14\n\
\x10\n\t\x04\x02\x03\0\x03\x02\x02\x01\x05\x12\x038\x15\x1a\n\x10\n\t\
\x04\x02\x03\0\x03\x02\x02\x01\x01\x12\x038\x1b%\n\x10\n\t\x04\x02\x03\0\
\x03\x02\x02\x01\x03\x12\x038()\n%\n\x08\x04\x02\x03\0\x03\x02\x02\x02\
\x12\x039\x0c'\"\x14\x20Amount\x20to\x20transfer\n\n\x10\n\t\x04\x02\x03\
\0\x03\x02\x02\x02\x04\x12\x039\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x02\
\x02\x02\x05\x12\x039\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\x02\
\x01\x12\x039\x1c\"\n\x10\n\t\x04\x02\x03\0\x03\x02\x02\x02\x03\x12\x039\
%&\n\x1e\n\x06\x04\x02\x03\0\x03\x03\x12\x04<\x08B\t\x1a\x0e\x20Vote\x20\
witness\n\n\x0e\n\x07\x04\x02\x03\0\x03\x03\x01\x12\x03<\x10'\n\x10\n\
\x08\x04\x02\x03\0\x03\x03\x03\0\x12\x04=\x0c@\r\n\x10\n\t\x04\x02\x03\0\
\x03\x03\x03\0\x01\x12\x03=\x14\x1c\n8\n\n\x04\x02\x03\0\x03\x03\x03\0\
\x02\0\x12\x03>\x100\"%\x20Candidate\x20Address\x20-\x20decoded\x20base\
\x2058\n\n\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\0\x04\x12\x03>\x10\
\x18\n\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\0\x05\x12\x03>\x19\x1e\
\n\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\0\x01\x12\x03>\x1f+\n\x12\n\
\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\0\x03\x12\x03>./\n$\n\n\x04\x02\x03\
\0\x03\x03\x03\0\x02\x01\x12\x03?\x10/\"\x11\x20Amount\x20of\x20votes\n\
\n\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\x01\x04\x12\x03?\x10\x18\n\
\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\x01\x05\x12\x03?\x19\x1f\n\
\x12\n\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\x01\x01\x12\x03?\x20*\n\x12\n\
\x0b\x04\x02\x03\0\x03\x03\x03\0\x02\x01\x03\x12\x03?-.\n\x18\n\x08\x04\
\x02\x03\0\x03\x03\x02\0\x12\x03A\x0c(\"\x07\x20votes\n\n\x10\n\t\x04\
\x02\x03\0\x03\x03\x02\0\x04\x12\x03A\x0c\x14\n\x10\n\t\x04\x02\x03\0\
\x03\x03\x02\0\x06\x12\x03A\x15\x1d\n\x10\n\t\x04\x02\x03\0\x03\x03\x02\
\0\x01\x12\x03A\x1e#\n\x10\n\t\x04\x02\x03\0\x03\x03\x02\0\x03\x12\x03A&\
'\n,\n\x06\x04\x02\x03\0\x03\x04\x12\x04D\x08F\t\x1a\x1c\x20Upgrade\x20a\
ccount\x20to\x20witness\n\n\x0e\n\x07\x04\x02\x03\0\x03\x04\x01\x12\x03D\
\x10)\n\x1e\n\x08\x04\x02\x03\0\x03\x04\x02\0\x12\x03E\x0c$\"\r\x20Witne\
ss\x20URL\n\n\x10\n\t\x04\x02\x03\0\x03\x04\x02\0\x04\x12\x03E\x0c\x14\n\
\x10\n\t\x04\x02\x03\0\x03\x04\x02\0\x05\x12\x03E\x15\x1b\n\x10\n\t\x04\
\x02\x03\0\x03\x04\x02\0\x01\x12\x03E\x1c\x1f\n\x10\n\t\x04\x02\x03\0\
\x03\x04\x02\0\x03\x12\x03E\"#\n$\n\x06\x04\x02\x03\0\x03\x05\x12\x04H\
\x08J\t\x1a\x14\x20Update\x20witness\x20URL\n\n\x0e\n\x07\x04\x02\x03\0\
\x03\x05\x01\x12\x03H\x10)\n\x1e\n\x08\x04\x02\x03\0\x03\x05\x02\0\x12\
\x03I\x0c+\"\r\x20Witness\x20URL\n\n\x10\n\t\x04\x02\x03\0\x03\x05\x02\0\
\x04\x12\x03I\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x05\x02\0\x05\x12\x03I\
\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x05\x02\0\x01\x12\x03I\x1c&\n\x10\n\
\t\x04\x02\x03\0\x03\x05\x02\0\x03\x12\x03I)*\n\x1d\n\x06\x04\x02\x03\0\
\x03\x06\x12\x04L\x08[\t\x1a\r\x20Issue\x20Asset\n\n\x0e\n\x07\x04\x02\
\x03\0\x03\x06\x01\x12\x03L\x10&\n\x10\n\x08\x04\x02\x03\0\x03\x06\x03\0\
\x12\x04M\x0cP\r\n\x10\n\t\x04\x02\x03\0\x03\x06\x03\0\x01\x12\x03M\x14$\
\n\"\n\n\x04\x02\x03\0\x03\x06\x03\0\x02\0\x12\x03N\x102\"\x0f\x20Amount\
\x20frozen\n\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\0\x04\x12\x03N\
\x10\x18\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\0\x05\x12\x03N\x19\
\x1f\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\0\x01\x12\x03N\x20-\n\
\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\0\x03\x12\x03N01\n)\n\n\x04\
\x02\x03\0\x03\x06\x03\0\x02\x01\x12\x03O\x100\"\x16\x20Days\x20from\x20\
issue\x20date\n\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\x01\x04\x12\
\x03O\x10\x18\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\x01\x05\x12\
\x03O\x19\x1f\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\x01\x01\x12\
\x03O\x20+\n\x12\n\x0b\x04\x02\x03\0\x03\x06\x03\0\x02\x01\x03\x12\x03O.\
/\n\x1d\n\x08\x04\x02\x03\0\x03\x06\x02\0\x12\x03Q\x0c%\"\x0c\x20Asset\
\x20name\n\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\0\x04\x12\x03Q\x0c\x14\n\
\x10\n\t\x04\x02\x03\0\x03\x06\x02\0\x05\x12\x03Q\x15\x1b\n\x10\n\t\x04\
\x02\x03\0\x03\x06\x02\0\x01\x12\x03Q\x1c\x20\n\x10\n\t\x04\x02\x03\0\
\x03\x06\x02\0\x03\x12\x03Q#$\n%\n\x08\x04\x02\x03\0\x03\x06\x02\x01\x12\
\x03R\x0c%\"\x14\x20Asset\x20abbreviation\n\n\x10\n\t\x04\x02\x03\0\x03\
\x06\x02\x01\x04\x12\x03R\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\
\x01\x05\x12\x03R\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x01\x01\
\x12\x03R\x1c\x20\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x01\x03\x12\x03R#$\
\n0\n\x08\x04\x02\x03\0\x03\x06\x02\x02\x12\x03S\x0c-\"\x1f\x20Total\x20\
supply\x20including\x20frozen\n\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x02\
\x04\x12\x03S\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x02\x05\x12\
\x03S\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x02\x01\x12\x03S\x1c(\
\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x02\x03\x12\x03S+,\n\x20\n\x08\x04\
\x02\x03\0\x03\x06\x02\x03\x12\x03T\x0c8\"\x0f\x20Frozen\x20supply\n\n\
\x10\n\t\x04\x02\x03\0\x03\x06\x02\x03\x04\x12\x03T\x0c\x14\n\x10\n\t\
\x04\x02\x03\0\x03\x06\x02\x03\x06\x12\x03T\x15%\n\x10\n\t\x04\x02\x03\0\
\x03\x06\x02\x03\x01\x12\x03T&3\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x03\
\x03\x12\x03T67\n1\n\x08\x04\x02\x03\0\x03\x06\x02\x04\x12\x03U\x0c(\"\
\x20\x20Amount\x20of\x20TRX\x20(exchange\x20ratio)\n\n\x10\n\t\x04\x02\
\x03\0\x03\x06\x02\x04\x04\x12\x03U\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\
\x06\x02\x04\x05\x12\x03U\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\
\x04\x01\x12\x03U\x1c#\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x04\x03\x12\
\x03U&'\n4\n\x08\x04\x02\x03\0\x03\x06\x02\x05\x12\x03V\x0c$\"#\x20Amoun\
t\x20of\x20tokens\x20(exchange\x20ratio)\n\n\x10\n\t\x04\x02\x03\0\x03\
\x06\x02\x05\x04\x12\x03V\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\
\x05\x05\x12\x03V\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x05\x01\
\x12\x03V\x1c\x1f\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x05\x03\x12\x03V\"\
#\n2\n\x08\x04\x02\x03\0\x03\x06\x02\x06\x12\x03W\x0c+\"!\x20Negotiation\
\x20start\x20date\x20and\x20time\n\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\
\x06\x04\x12\x03W\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x06\x05\
\x12\x03W\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x06\x01\x12\x03W\
\x1c&\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x06\x03\x12\x03W)*\n0\n\x08\
\x04\x02\x03\0\x03\x06\x02\x07\x12\x03X\x0c)\"\x1f\x20Negotiation\x20end\
\x20date\x20and\x20time\n\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x07\x04\
\x12\x03X\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x07\x05\x12\x03X\
\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x07\x01\x12\x03X\x1c$\n\x10\
\n\t\x04\x02\x03\0\x03\x06\x02\x07\x03\x12\x03X'(\n$\n\x08\x04\x02\x03\0\
\x03\x06\x02\x08\x12\x03Y\x0c-\"\x13\x20Asset\x20description\n\n\x10\n\t\
\x04\x02\x03\0\x03\x06\x02\x08\x04\x12\x03Y\x0c\x14\n\x10\n\t\x04\x02\
\x03\0\x03\x06\x02\x08\x05\x12\x03Y\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\
\x06\x02\x08\x01\x12\x03Y\x1c'\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\x08\
\x03\x12\x03Y*,\n\x1c\n\x08\x04\x02\x03\0\x03\x06\x02\t\x12\x03Z\x0c%\"\
\x0b\x20Asset\x20URL\n\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\t\x04\x12\x03\
Z\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x06\x02\t\x05\x12\x03Z\x15\x1b\n\
\x10\n\t\x04\x02\x03\0\x03\x06\x02\t\x01\x12\x03Z\x1c\x1f\n\x10\n\t\x04\
\x02\x03\0\x03\x06\x02\t\x03\x12\x03Z\"$\n*\n\x06\x04\x02\x03\0\x03\x07\
\x12\x04]\x08a\t\x1a\x1a\x20Participate\x20in\x20an\x20asset\x20\n\n\x0e\
\n\x07\x04\x02\x03\0\x03\x07\x01\x12\x03]\x101\n9\n\x08\x04\x02\x03\0\
\x03\x07\x02\0\x12\x03^\x0c*\"(\x20Asset\x20issuer\x20address\x20-\x20de\
coded\x20base\x2058\n\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\0\x04\x12\x03^\
\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\0\x05\x12\x03^\x15\x1a\n\
\x10\n\t\x04\x02\x03\0\x03\x07\x02\0\x01\x12\x03^\x1b%\n\x10\n\t\x04\x02\
\x03\0\x03\x07\x02\0\x03\x12\x03^()\n+\n\x08\x04\x02\x03\0\x03\x07\x02\
\x01\x12\x03_\x0c+\"\x1a\x20The\x20name\x20of\x20target\x20asset\n\n\x10\
\n\t\x04\x02\x03\0\x03\x07\x02\x01\x04\x12\x03_\x0c\x14\n\x10\n\t\x04\
\x02\x03\0\x03\x07\x02\x01\x05\x12\x03_\x15\x1b\n\x10\n\t\x04\x02\x03\0\
\x03\x07\x02\x01\x01\x12\x03_\x1c&\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\
\x01\x03\x12\x03_)*\n$\n\x08\x04\x02\x03\0\x03\x07\x02\x02\x12\x03`\x0c'\
\"\x13\x20TRX\x20amount\x20in\x20sun\n\n\x10\n\t\x04\x02\x03\0\x03\x07\
\x02\x02\x04\x12\x03`\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\x02\
\x05\x12\x03`\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\x02\x01\x12\
\x03`\x1c\"\n\x10\n\t\x04\x02\x03\0\x03\x07\x02\x02\x03\x12\x03`%&\n<\n\
\x06\x04\x02\x03\0\x03\x08\x12\x04c\x08f\t\x1a,\x20Freeze\x20TRX\x20bala\
nce\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\n\n\x0e\n\x07\x04\x02\x03\0\x03\x08\x01\x12\
\x03c\x10)\n#\n\x08\x04\x02\x03\0\x03\x08\x02\0\x12\x03d\x0c/\"\x12\x20A\
mount\x20to\x20freeze\n\n\x10\n\t\x04\x02\x03\0\x03\x08\x02\0\x04\x12\
\x03d\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x08\x02\0\x05\x12\x03d\x15\x1b\
\n\x10\n\t\x04\x02\x03\0\x03\x08\x02\0\x01\x12\x03d\x1c*\n\x10\n\t\x04\
\x02\x03\0\x03\x08\x02\0\x03\x12\x03d-.\n2\n\x08\x04\x02\x03\0\x03\x08\
\x02\x01\x12\x03e\x0c0\"!\x20Freeze\x20minimal\x20duration\x20in\x20days\
\n\n\x10\n\t\x04\x02\x03\0\x03\x08\x02\x01\x04\x12\x03e\x0c\x14\n\x10\n\
\t\x04\x02\x03\0\x03\x08\x02\x01\x05\x12\x03e\x15\x1b\n\x10\n\t\x04\x02\
\x03\0\x03\x08\x02\x01\x01\x12\x03e\x1c+\n\x10\n\t\x04\x02\x03\0\x03\x08\
\x02\x01\x03\x12\x03e./\n&\n\x06\x04\x02\x03\0\x03\t\x12\x04h\x08i\t\x1a\
\x16\x20Unfreeze\x20TRX\x20Balance\n\n\x0e\n\x07\x04\x02\x03\0\x03\t\x01\
\x12\x03h\x10+\n(\n\x06\x04\x02\x03\0\x03\n\x12\x04k\x08l\t\x1a\x18\x20U\
nfreeze\x20Asset\x20Balance\n\n\x0e\n\x07\x04\x02\x03\0\x03\n\x01\x12\
\x03k\x10)\n*\n\x06\x04\x02\x03\0\x03\x0b\x12\x04n\x08o\t\x1a\x1a\x20Wit\
hdraw\x20witness\x20balance\n\n\x0e\n\x07\x04\x02\x03\0\x03\x0b\x01\x12\
\x03n\x10+\n\x1e\n\x06\x04\x02\x03\0\x03\x0c\x12\x04q\x08t\t\x1a\x0e\x20\
Update\x20Asset\n\n\x0e\n\x07\x04\x02\x03\0\x03\x0c\x01\x12\x03q\x10'\n\
\"\n\x08\x04\x02\x03\0\x03\x0c\x02\0\x12\x03r\x0c,\"\x11\x20New\x20descr\
iption\n\n\x10\n\t\x04\x02\x03\0\x03\x0c\x02\0\x04\x12\x03r\x0c\x14\n\
\x10\n\t\x04\x02\x03\0\x03\x0c\x02\0\x05\x12\x03r\x15\x1b\n\x10\n\t\x04\
\x02\x03\0\x03\x0c\x02\0\x01\x12\x03r\x1c'\n\x10\n\t\x04\x02\x03\0\x03\
\x0c\x02\0\x03\x12\x03r*+\n\x1a\n\x08\x04\x02\x03\0\x03\x0c\x02\x01\x12\
\x03s\x0c$\"\t\x20New\x20URL\n\n\x10\n\t\x04\x02\x03\0\x03\x0c\x02\x01\
\x04\x12\x03s\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x0c\x02\x01\x05\x12\
\x03s\x15\x1b\n\x10\n\t\x04\x02\x03\0\x03\x0c\x02\x01\x01\x12\x03s\x1c\
\x1f\n\x10\n\t\x04\x02\x03\0\x03\x0c\x02\x01\x03\x12\x03s\"#\n+\n\x06\
\x04\x02\x03\0\x03\r\x12\x04v\x08|\t\x1a\x1b\x20Network\x20proposal\x20c\
ontract\n\n\x0e\n\x07\x04\x02\x03\0\x03\r\x01\x12\x03v\x10*\n\x10\n\x08\
\x04\x02\x03\0\x03\r\x03\0\x12\x04w\x0cz\r\n\x10\n\t\x04\x02\x03\0\x03\r\
\x03\0\x01\x12\x03w\x14*\n!\n\n\x04\x02\x03\0\x03\r\x03\0\x02\0\x12\x03x\
\x10(\"\x0e\x20Paramter\x20key\n\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\
\x02\0\x04\x12\x03x\x10\x18\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\0\
\x05\x12\x03x\x19\x1f\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\0\x01\
\x12\x03x\x20#\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\0\x03\x12\x03x&\
'\n$\n\n\x04\x02\x03\0\x03\r\x03\0\x02\x01\x12\x03y\x10*\"\x11\x20Parame\
ter\x20value\n\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\x01\x04\x12\x03\
y\x10\x18\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\x01\x05\x12\x03y\x19\
\x1f\n\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\x01\x01\x12\x03y\x20%\n\
\x12\n\x0b\x04\x02\x03\0\x03\r\x03\0\x02\x01\x03\x12\x03y()\n*\n\x08\x04\
\x02\x03\0\x03\r\x02\0\x12\x03{\x0c;\"\x19\x20Parameter\x20to\x20be\x20c\
hanged\n\n\x10\n\t\x04\x02\x03\0\x03\r\x02\0\x04\x12\x03{\x0c\x14\n\x10\
\n\t\x04\x02\x03\0\x03\r\x02\0\x06\x12\x03{\x15+\n\x10\n\t\x04\x02\x03\0\
\x03\r\x02\0\x01\x12\x03{,6\n\x10\n\t\x04\x02\x03\0\x03\r\x02\0\x03\x12\
\x03{9:\n$\n\x06\x04\x02\x03\0\x03\x0e\x12\x05~\x08\x81\x01\t\x1a\x13\
\x20Approval\x20contract\n\n\x0e\n\x07\x04\x02\x03\0\x03\x0e\x01\x12\x03\
~\x10+\n\x1e\n\x08\x04\x02\x03\0\x03\x0e\x02\0\x12\x03\x7f\x0c,\"\r\x20P\
roposal\x20ID\n\n\x10\n\t\x04\x02\x03\0\x03\x0e\x02\0\x04\x12\x03\x7f\
\x0c\x14\n\x10\n\t\x04\x02\x03\0\x03\x0e\x02\0\x05\x12\x03\x7f\x15\x1b\n\
\x10\n\t\x04\x02\x03\0\x03\x0e\x02\0\x01\x12\x03\x7f\x1c'\n\x10\n\t\x04\
\x02\x03\0\x03\x0e\x02\0\x03\x12\x03\x7f*+\n*\n\x08\x04\x02\x03\0\x03\
\x0e\x02\x01\x12\x04\x80\x01\x0c.\"\x18\x20Add\x20or\x20remove\x20approv\
al\n\n\x11\n\t\x04\x02\x03\0\x03\x0e\x02\x01\x04\x12\x04\x80\x01\x0c\x14\
\n\x11\n\t\x04\x02\x03\0\x03\x0e\x02\x01\x05\x12\x04\x80\x01\x15\x19\n\
\x11\n\t\x04\x02\x03\0\x03\x0e\x02\x01\x01\x12\x04\x80\x01\x1a)\n\x11\n\
\t\x04\x02\x03\0\x03\x0e\x02\x01\x03\x12\x04\x80\x01,-\n#\n\x06\x04\x02\
\x03\0\x03\x0f\x12\x06\x83\x01\x08\x85\x01\t\x1a\x11\x20Delete\x20propos\
al\n\n\x0f\n\x07\x04\x02\x03\0\x03\x0f\x01\x12\x04\x83\x01\x10*\n\x1f\n\
\x08\x04\x02\x03\0\x03\x0f\x02\0\x12\x04\x84\x01\x0c,\"\r\x20Proposal\
\x20ID\n\n\x11\n\t\x04\x02\x03\0\x03\x0f\x02\0\x04\x12\x04\x84\x01\x0c\
\x14\n\x11\n\t\x04\x02\x03\0\x03\x0f\x02\0\x05\x12\x04\x84\x01\x15\x1b\n\
\x11\n\t\x04\x02\x03\0\x03\x0f\x02\0\x01\x12\x04\x84\x01\x1c'\n\x11\n\t\
\x04\x02\x03\0\x03\x0f\x02\0\x03\x12\x04\x84\x01*+\n\x0e\n\x06\x04\x02\
\x03\0\x02\0\x12\x04\x87\x01\x08<\n\x0f\n\x07\x04\x02\x03\0\x02\0\x04\
\x12\x04\x87\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\x02\0\x06\x12\x04\x87\
\x01\x11%\n\x0f\n\x07\x04\x02\x03\0\x02\0\x01\x12\x04\x87\x01&7\n\x0f\n\
\x07\x04\x02\x03\0\x02\0\x03\x12\x04\x87\x01:;\n\x0e\n\x06\x04\x02\x03\0\
\x02\x01\x12\x04\x88\x01\x08G\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x04\x12\
\x04\x88\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x06\x12\x04\x88\
\x01\x11*\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\x88\x01+B\n\x0f\
\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\x88\x01EF\n\x0e\n\x06\x04\x02\
\x03\0\x02\x02\x12\x04\x89\x01\x08C\n\x0f\n\x07\x04\x02\x03\0\x02\x02\
\x04\x12\x04\x89\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\x02\x02\x06\x12\
\x04\x89\x01\x11(\n\x0f\n\x07\x04\x02\x03\0\x02\x02\x01\x12\x04\x89\x01)\
>\n\x0f\n\x07\x04\x02\x03\0\x02\x02\x03\x12\x04\x89\x01AB\n\x0e\n\x06\
\x04\x02\x03\0\x02\x03\x12\x04\x8a\x01\x08G\n\x0f\n\x07\x04\x02\x03\0\
\x02\x03\x04\x12\x04\x8a\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\x02\x03\
\x06\x12\x04\x8a\x01\x11*\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x01\x12\x04\
\x8a\x01+B\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x03\x12\x04\x8a\x01EF\n\x0e\
\n\x06\x04\x02\x03\0\x02\x04\x12\x04\x8b\x01\x08A\n\x0f\n\x07\x04\x02\
\x03\0\x02\x04\x04\x12\x04\x8b\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\x02\
\x04\x06\x12\x04\x8b\x01\x11'\n\x0f\n\x07\x04\x02\x03\0\x02\x04\x01\x12\
\x04\x8b\x01(<\n\x0f\n\x07\x04\x02\x03\0\x02\x04\x03\x12\x04\x8b\x01?@\n\
\x0e\n\x06\x04\x02\x03\0\x02\x05\x12\x04\x8c\x01\x08G\n\x0f\n\x07\x04\
\x02\x03\0\x02\x05\x04\x12\x04\x8c\x01\x08\x10\n\x0f\n\x07\x04\x02\x03\0\
\x02\x05\x06\x12\x04\x8c\x01\x11*\n\x0f\n\x07\x04\x02\x03\0\x02\x05\x01\
\x12\x04\x8c\x01+B\n\x0f\n\x07\x04\x02\x03\0\x02\x05\x03\x12\x04\x8c\x01\
EF\n\x0e\n\x06\x04\x02\x03\0\x02\x06\x12\x04\x8d\x01\x08X\n\x0f\n\x07\
\x04\x02\x03\0\x02\x06\x04\x12\x04\x8d\x01\x08\x10\n\x0f\n\x07\x04\x02\
\x03\0\x02\x06\x06\x12\x04\x8d\x01\x112\n\x0f\n\x07\x04\x02\x03\0\x02\
\x06\x01\x12\x04\x8d\x013S\n\x0f\n\x07\x04\x02\x03\0\x02\x06\x03\x12\x04\
\x8d\x01VW\n\x0e\n\x06\x04\x02\x03\0\x02\x07\x12\x04\x8e\x01\x08H\n\x0f\
\n\x07\x04\x02\x03\0\x02\x07\x04\x12\x04\x8e\x01\x08\x10\n\x0f\n\x07\x04\
\x02\x03\0\x02\x07\x06\x12\x04\x8e\x01\x11*\n\x0f\n\x07\x04\x02\x03\0\
\x02\x07\x01\x12\x04\x8e\x01+B\n\x0f\n\x07\x04\x02\x03\0\x02\x07\x03\x12\
\x04\x8e\x01EG\n\x0e\n\x06\x04\x02\x03\0\x02\x08\x12\x04\x8f\x01\x08H\n\
\x0f\n\x07\x04\x02\x03\0\x02\x08\x04\x12\x04\x8f\x01\x08\x10\n\x0f\n\x07\
\x04\x02\x03\0\x02\x08\x06\x12\x04\x8f\x01\x11*\n\x0f\n\x07\x04\x02\x03\
\0\x02\x08\x01\x12\x04\x8f\x01+B\n\x0f\n\x07\x04\x02\x03\0\x02\x08\x03\
\x12\x04\x8f\x01EG\n\x0e\n\x06\x04\x02\x03\0\x02\t\x12\x04\x90\x01\x08L\
\n\x0f\n\x07\x04\x02\x03\0\x02\t\x04\x12\x04\x90\x01\x08\x10\n\x0f\n\x07\
\x04\x02\x03\0\x02\t\x06\x12\x04\x90\x01\x11,\n\x0f\n\x07\x04\x02\x03\0\
\x02\t\x01\x12\x04\x90\x01-F\n\x0f\n\x07\x04\x02\x03\0\x02\t\x03\x12\x04\
\x90\x01IK\n\x0e\n\x06\x04\x02\x03\0\x02\n\x12\x04\x91\x01\x08L\n\x0f\n\
\x07\x04\x02\x03\0\x02\n\x04\x12\x04\x91\x01\x08\x10\n\x0f\n\x07\x04\x02\
\x03\0\x02\n\x06\x12\x04\x91\x01\x11,\n\x0f\n\x07\x04\x02\x03\0\x02\n\
\x01\x12\x04\x91\x01-F\n\x0f\n\x07\x04\x02\x03\0\x02\n\x03\x12\x04\x91\
\x01IK\n\x0e\n\x06\x04\x02\x03\0\x02\x0b\x12\x04\x92\x01\x08H\n\x0f\n\
\x07\x04\x02\x03\0\x02\x0b\x04\x12\x04\x92\x01\x08\x10\n\x0f\n\x07\x04\
\x02\x03\0\x02\x0b\x06\x12\x04\x92\x01\x11*\n\x0f\n\x07\x04\x02\x03\0\
\x02\x0b\x01\x12\x04\x92\x01+B\n\x0f\n\x07\x04\x02\x03\0\x02\x0b\x03\x12\
\x04\x92\x01EG\n\x0e\n\x06\x04\x02\x03\0\x02\x0c\x12\x04\x93\x01\x08D\n\
\x0f\n\x07\x04\x02\x03\0\x02\x0c\x04\x12\x04\x93\x01\x08\x10\n\x0f\n\x07\
\x04\x02\x03\0\x02\x0c\x06\x12\x04\x93\x01\x11(\n\x0f\n\x07\x04\x02\x03\
\0\x02\x0c\x01\x12\x04\x93\x01)>\n\x0f\n\x07\x04\x02\x03\0\x02\x0c\x03\
\x12\x04\x93\x01AC\n\x0e\n\x06\x04\x02\x03\0\x02\r\x12\x04\x94\x01\x08J\
\n\x0f\n\x07\x04\x02\x03\0\x02\r\x04\x12\x04\x94\x01\x08\x10\n\x0f\n\x07\
\x04\x02\x03\0\x02\r\x06\x12\x04\x94\x01\x11+\n\x0f\n\x07\x04\x02\x03\0\
\x02\r\x01\x12\x04\x94\x01,D\n\x0f\n\x07\x04\x02\x03\0\x02\r\x03\x12\x04\
\x94\x01GI\n\x0e\n\x06\x04\x02\x03\0\x02\x0e\x12\x04\x95\x01\x08L\n\x0f\
\n\x07\x04\x02\x03\0\x02\x0e\x04\x12\x04\x95\x01\x08\x10\n\x0f\n\x07\x04\
\x02\x03\0\x02\x0e\x06\x12\x04\x95\x01\x11,\n\x0f\n\x07\x04\x02\x03\0\
\x02\x0e\x01\x12\x04\x95\x01-F\n\x0f\n\x07\x04\x02\x03\0\x02\x0e\x03\x12\
\x04\x95\x01IK\n\x0e\n\x06\x04\x02\x03\0\x02\x0f\x12\x04\x96\x01\x08J\n\
\x0f\n\x07\x04\x02\x03\0\x02\x0f\x04\x12\x04\x96\x01\x08\x10\n\x0f\n\x07\
\x04\x02\x03\0\x02\x0f\x06\x12\x04\x96\x01\x11+\n\x0f\n\x07\x04\x02\x03\
\0\x02\x0f\x01\x12\x04\x96\x01,D\n\x0f\n\x07\x04\x02\x03\0\x02\x0f\x03\
\x12\x04\x96\x01GI\nQ\n\x02\x04\x03\x12\x06\x9e\x01\0\xa1\x01\x01\x1aC*\
\n\x20Response:\x20Contains\x20Tron\x20transaction\x20signature\n\x20@pr\
ev\x20TronSignTx\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x9e\x01\x08\x14\n%\n\
\x04\x04\x03\x02\0\x12\x04\x9f\x01\x04!\"\x17\x20Transaction\x20signatur\
e\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\x9f\x01\x04\x0c\n\r\n\x05\x04\
\x03\x02\0\x05\x12\x04\x9f\x01\r\x12\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\
\x9f\x01\x13\x1c\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x9f\x01\x1f\x20\n&\
\n\x04\x04\x03\x02\x01\x12\x04\xa0\x01\x04%\"\x18\x20Serialized\x20trans\
action\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04\xa0\x01\x04\x0c\n\r\n\x05\
\x04\x03\x02\x01\x05\x12\x04\xa0\x01\r\x12\n\r\n\x05\x04\x03\x02\x01\x01\
\x12\x04\xa0\x01\x13\x20\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xa0\x01#$\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}