// This file is generated by rust-protobuf 2.0.4. Do not edit
// @generated

// https://github.com/Manishearth/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy)]

#![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(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

#[derive(PartialEq,Clone,Default)]
pub struct TronGetAddress {
    // message fields
    address_n: ::std::vec::Vec<u32>,
    show_display: ::std::option::Option<bool>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // repeated uint32 address_n = 1;

    pub fn clear_address_n(&mut self) {
        self.address_n.clear();
    }

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

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

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

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

    // optional bool show_display = 2;

    pub fn clear_show_display(&mut self) {
        self.show_display = ::std::option::Option::None;
    }

    pub fn has_show_display(&self) -> bool {
        self.show_display.is_some()
    }

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

    pub fn get_show_display(&self) -> bool {
        self.show_display.unwrap_or(false)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.address_n {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronGetAddress>(
                    "TronGetAddress",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronGetAddress {
        static mut instance: ::protobuf::lazy::Lazy<TronGetAddress> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronGetAddress,
        };
        unsafe {
            instance.get(TronGetAddress::new)
        }
    }
}

impl ::protobuf::Clear for TronGetAddress {
    fn clear(&mut self) {
        self.clear_address_n();
        self.clear_show_display();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

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

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

    // optional string address = 1;

    pub fn clear_address(&mut self) {
        self.address.clear();
    }

    pub fn has_address(&self) -> bool {
        self.address.is_some()
    }

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

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

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

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

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(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.address.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronAddress>(
                    "TronAddress",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronAddress {
        static mut instance: ::protobuf::lazy::Lazy<TronAddress> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronAddress,
        };
        unsafe {
            instance.get(TronAddress::new)
        }
    }
}

impl ::protobuf::Clear for TronAddress {
    fn clear(&mut self) {
        self.clear_address();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx {
    // message fields
    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>,
    contract: ::protobuf::SingularPtrField<TronSignTx_TronContract>,
    timestamp: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // repeated uint32 address_n = 1;

    pub fn clear_address_n(&mut self) {
        self.address_n.clear();
    }

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

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

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

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

    // optional bytes ref_block_bytes = 2;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_bytes(&self) -> &[u8] {
        match self.ref_block_bytes.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional bytes ref_block_hash = 3;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_ref_block_hash(&self) -> &[u8] {
        match self.ref_block_hash.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional uint64 expiration = 4;

    pub fn clear_expiration(&mut self) {
        self.expiration = ::std::option::Option::None;
    }

    pub fn has_expiration(&self) -> bool {
        self.expiration.is_some()
    }

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

    pub fn get_expiration(&self) -> u64 {
        self.expiration.unwrap_or(0)
    }

    // optional string data = 5;

    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

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

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

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

    pub fn get_data(&self) -> &str {
        match self.data.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional .TronSignTx.TronContract contract = 6;

    pub fn clear_contract(&mut self) {
        self.contract.clear();
    }

    pub fn has_contract(&self) -> bool {
        self.contract.is_some()
    }

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

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

    // Take field
    pub fn take_contract(&mut self) -> TronSignTx_TronContract {
        self.contract.take().unwrap_or_else(|| TronSignTx_TronContract::new())
    }

    pub fn get_contract(&self) -> &TronSignTx_TronContract {
        self.contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract::default_instance())
    }

    // optional uint64 timestamp = 7;

    pub fn clear_timestamp(&mut self) {
        self.timestamp = ::std::option::Option::None;
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

    pub fn get_timestamp(&self) -> u64 {
        self.timestamp.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.address_n {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx>(
                    "TronSignTx",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx,
        };
        unsafe {
            instance.get(TronSignTx::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx {
    fn clear(&mut self) {
        self.clear_address_n();
        self.clear_ref_block_bytes();
        self.clear_ref_block_hash();
        self.clear_expiration();
        self.clear_data();
        self.clear_contract();
        self.clear_timestamp();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract {
    // message fields
    transfer_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronTransferContract>,
    transfer_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronTransferAssetContract>,
    vote_witness_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronVoteWitnessContract>,
    witness_create_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWitnessCreateContract>,
    asset_issue_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronAssetIssueContract>,
    witness_update_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWitnessUpdateContract>,
    participate_asset_issue_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronParticipateAssetIssueContract>,
    account_update_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronAccountUpdateContract>,
    freeze_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronFreezeBalanceContract>,
    unfreeze_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUnfreezeBalanceContract>,
    withdraw_balance_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronWithdrawBalanceContract>,
    unfreeze_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUnfreezeAssetContract>,
    update_asset_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronUpdateAssetContract>,
    proposal_create_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalCreateContract>,
    proposal_approve_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalApproveContract>,
    proposal_delete_contract: ::protobuf::SingularPtrField<TronSignTx_TronContract_TronProposalDeleteContract>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional .TronSignTx.TronContract.TronTransferContract transfer_contract = 1;

    pub fn clear_transfer_contract(&mut self) {
        self.transfer_contract.clear();
    }

    pub fn has_transfer_contract(&self) -> bool {
        self.transfer_contract.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_contract(&self) -> &TronSignTx_TronContract_TronTransferContract {
        self.transfer_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronTransferContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronTransferAssetContract transfer_asset_contract = 2;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_transfer_asset_contract(&self) -> &TronSignTx_TronContract_TronTransferAssetContract {
        self.transfer_asset_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronTransferAssetContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronVoteWitnessContract vote_witness_contract = 4;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_vote_witness_contract(&self) -> &TronSignTx_TronContract_TronVoteWitnessContract {
        self.vote_witness_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronVoteWitnessContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronWitnessCreateContract witness_create_contract = 5;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_witness_create_contract(&self) -> &TronSignTx_TronContract_TronWitnessCreateContract {
        self.witness_create_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronWitnessCreateContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronAssetIssueContract asset_issue_contract = 6;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_asset_issue_contract(&self) -> &TronSignTx_TronContract_TronAssetIssueContract {
        self.asset_issue_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronAssetIssueContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronWitnessUpdateContract witness_update_contract = 8;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_witness_update_contract(&self) -> &TronSignTx_TronContract_TronWitnessUpdateContract {
        self.witness_update_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronWitnessUpdateContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronParticipateAssetIssueContract participate_asset_issue_contract = 9;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_participate_asset_issue_contract(&self) -> &TronSignTx_TronContract_TronParticipateAssetIssueContract {
        self.participate_asset_issue_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronParticipateAssetIssueContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronAccountUpdateContract account_update_contract = 10;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_account_update_contract(&self) -> &TronSignTx_TronContract_TronAccountUpdateContract {
        self.account_update_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronAccountUpdateContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronFreezeBalanceContract freeze_balance_contract = 11;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_freeze_balance_contract(&self) -> &TronSignTx_TronContract_TronFreezeBalanceContract {
        self.freeze_balance_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronFreezeBalanceContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronUnfreezeBalanceContract unfreeze_balance_contract = 12;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_unfreeze_balance_contract(&self) -> &TronSignTx_TronContract_TronUnfreezeBalanceContract {
        self.unfreeze_balance_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronUnfreezeBalanceContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronWithdrawBalanceContract withdraw_balance_contract = 13;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_withdraw_balance_contract(&self) -> &TronSignTx_TronContract_TronWithdrawBalanceContract {
        self.withdraw_balance_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronWithdrawBalanceContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronUnfreezeAssetContract unfreeze_asset_contract = 14;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_unfreeze_asset_contract(&self) -> &TronSignTx_TronContract_TronUnfreezeAssetContract {
        self.unfreeze_asset_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronUnfreezeAssetContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronUpdateAssetContract update_asset_contract = 15;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_update_asset_contract(&self) -> &TronSignTx_TronContract_TronUpdateAssetContract {
        self.update_asset_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronUpdateAssetContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronProposalCreateContract proposal_create_contract = 16;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_create_contract(&self) -> &TronSignTx_TronContract_TronProposalCreateContract {
        self.proposal_create_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronProposalCreateContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronProposalApproveContract proposal_approve_contract = 17;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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_approve_contract(&self) -> &TronSignTx_TronContract_TronProposalApproveContract {
        self.proposal_approve_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronProposalApproveContract::default_instance())
    }

    // optional .TronSignTx.TronContract.TronProposalDeleteContract proposal_delete_contract = 18;

    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()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_proposal_delete_contract(&mut self) -> TronSignTx_TronContract_TronProposalDeleteContract {
        self.proposal_delete_contract.take().unwrap_or_else(|| TronSignTx_TronContract_TronProposalDeleteContract::new())
    }

    pub fn get_proposal_delete_contract(&self) -> &TronSignTx_TronContract_TronProposalDeleteContract {
        self.proposal_delete_contract.as_ref().unwrap_or_else(|| TronSignTx_TronContract_TronProposalDeleteContract::default_instance())
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract>(
                    "TronSignTx_TronContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract {
    fn clear(&mut self) {
        self.clear_transfer_contract();
        self.clear_transfer_asset_contract();
        self.clear_vote_witness_contract();
        self.clear_witness_create_contract();
        self.clear_asset_issue_contract();
        self.clear_witness_update_contract();
        self.clear_participate_asset_issue_contract();
        self.clear_account_update_contract();
        self.clear_freeze_balance_contract();
        self.clear_unfreeze_balance_contract();
        self.clear_withdraw_balance_contract();
        self.clear_unfreeze_asset_contract();
        self.clear_update_asset_contract();
        self.clear_proposal_create_contract();
        self.clear_proposal_approve_contract();
        self.clear_proposal_delete_contract();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAccountUpdateContract {
    // message fields
    account_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string account_name = 1;

    pub fn clear_account_name(&mut self) {
        self.account_name.clear();
    }

    pub fn has_account_name(&self) -> bool {
        self.account_name.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

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

    pub fn get_account_name(&self) -> &str {
        match self.account_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronAccountUpdateContract>(
                    "TronSignTx_TronContract_TronAccountUpdateContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronAccountUpdateContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronAccountUpdateContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronAccountUpdateContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronAccountUpdateContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronAccountUpdateContract {
    fn clear(&mut self) {
        self.clear_account_name();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronTransferContract {
    // message fields
    to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    amount: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional bytes to_address = 1;

    pub fn clear_to_address(&mut self) {
        self.to_address.clear();
    }

    pub fn has_to_address(&self) -> bool {
        self.to_address.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

    // Take field
    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_to_address(&self) -> &[u8] {
        match self.to_address.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional uint64 amount = 2;

    pub fn clear_amount(&mut self) {
        self.amount = ::std::option::Option::None;
    }

    pub fn has_amount(&self) -> bool {
        self.amount.is_some()
    }

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

    pub fn get_amount(&self) -> u64 {
        self.amount.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronTransferContract>(
                    "TronSignTx_TronContract_TronTransferContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronTransferContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronTransferContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronTransferContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronTransferContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronTransferContract {
    fn clear(&mut self) {
        self.clear_to_address();
        self.clear_amount();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronTransferAssetContract {
    // message fields
    asset_name: ::protobuf::SingularField<::std::string::String>,
    to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    amount: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string asset_name = 1;

    pub fn clear_asset_name(&mut self) {
        self.asset_name.clear();
    }

    pub fn has_asset_name(&self) -> bool {
        self.asset_name.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

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

    pub fn get_asset_name(&self) -> &str {
        match self.asset_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional bytes to_address = 2;

    pub fn clear_to_address(&mut self) {
        self.to_address.clear();
    }

    pub fn has_to_address(&self) -> bool {
        self.to_address.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

    // Take field
    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_to_address(&self) -> &[u8] {
        match self.to_address.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional uint64 amount = 3;

    pub fn clear_amount(&mut self) {
        self.amount = ::std::option::Option::None;
    }

    pub fn has_amount(&self) -> bool {
        self.amount.is_some()
    }

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

    pub fn get_amount(&self) -> u64 {
        self.amount.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronTransferAssetContract>(
                    "TronSignTx_TronContract_TronTransferAssetContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronTransferAssetContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronTransferAssetContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronTransferAssetContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronTransferAssetContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronTransferAssetContract {
    fn clear(&mut self) {
        self.clear_asset_name();
        self.clear_to_address();
        self.clear_amount();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronVoteWitnessContract {
    // message fields
    votes: ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // repeated .TronSignTx.TronContract.TronVoteWitnessContract.TronVote votes = 1;

    pub fn clear_votes(&mut self) {
        self.votes.clear();
    }

    // Param is passed by value, moved
    pub fn set_votes(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>) {
        self.votes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_votes(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> {
        &mut self.votes
    }

    // Take field
    pub fn take_votes(&mut self) -> ::protobuf::RepeatedField<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> {
        ::std::mem::replace(&mut self.votes, ::protobuf::RepeatedField::new())
    }

    pub fn get_votes(&self) -> &[TronSignTx_TronContract_TronVoteWitnessContract_TronVote] {
        &self.votes
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronVoteWitnessContract>(
                    "TronSignTx_TronContract_TronVoteWitnessContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronVoteWitnessContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronVoteWitnessContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronVoteWitnessContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronVoteWitnessContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronVoteWitnessContract {
    fn clear(&mut self) {
        self.clear_votes();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
    // message fields
    vote_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    vote_count: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional bytes vote_address = 1;

    pub fn clear_vote_address(&mut self) {
        self.vote_address.clear();
    }

    pub fn has_vote_address(&self) -> bool {
        self.vote_address.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

    // Take field
    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_address(&self) -> &[u8] {
        match self.vote_address.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional uint64 vote_count = 2;

    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()
    }

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

    pub fn get_vote_count(&self) -> u64 {
        self.vote_count.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronVoteWitnessContract_TronVote>(
                    "TronSignTx_TronContract_TronVoteWitnessContract_TronVote",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronVoteWitnessContract_TronVote> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronVoteWitnessContract_TronVote,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronVoteWitnessContract_TronVote::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronVoteWitnessContract_TronVote {
    fn clear(&mut self) {
        self.clear_vote_address();
        self.clear_vote_count();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWitnessCreateContract {
    // message fields
    url: ::protobuf::SingularField<::std::string::String>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string url = 1;

    pub fn clear_url(&mut self) {
        self.url.clear();
    }

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

    pub fn get_url(&self) -> &str {
        match self.url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronWitnessCreateContract>(
                    "TronSignTx_TronContract_TronWitnessCreateContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronWitnessCreateContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronWitnessCreateContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronWitnessCreateContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronWitnessCreateContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronWitnessCreateContract {
    fn clear(&mut self) {
        self.clear_url();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWitnessUpdateContract {
    // message fields
    update_url: ::protobuf::SingularField<::std::string::String>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string update_url = 2;

    pub fn clear_update_url(&mut self) {
        self.update_url.clear();
    }

    pub fn has_update_url(&self) -> bool {
        self.update_url.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

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

    pub fn get_update_url(&self) -> &str {
        match self.update_url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronWitnessUpdateContract>(
                    "TronSignTx_TronContract_TronWitnessUpdateContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronWitnessUpdateContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronWitnessUpdateContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronWitnessUpdateContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronWitnessUpdateContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronWitnessUpdateContract {
    fn clear(&mut self) {
        self.clear_update_url();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAssetIssueContract {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    abbr: ::protobuf::SingularField<::std::string::String>,
    total_supply: ::std::option::Option<u64>,
    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>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string name = 2;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

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

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

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

    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional string abbr = 3;

    pub fn clear_abbr(&mut self) {
        self.abbr.clear();
    }

    pub fn has_abbr(&self) -> bool {
        self.abbr.is_some()
    }

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

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

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

    pub fn get_abbr(&self) -> &str {
        match self.abbr.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional uint64 total_supply = 4;

    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()
    }

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

    pub fn get_total_supply(&self) -> u64 {
        self.total_supply.unwrap_or(0)
    }

    // repeated .TronSignTx.TronContract.TronAssetIssueContract.TronFrozenSupply frozen_supply = 5;

    pub fn clear_frozen_supply(&mut self) {
        self.frozen_supply.clear();
    }

    // Param is passed by value, moved
    pub fn set_frozen_supply(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>) {
        self.frozen_supply = v;
    }

    // Mutable pointer to the field.
    pub fn mut_frozen_supply(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply> {
        &mut self.frozen_supply
    }

    // Take field
    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_frozen_supply(&self) -> &[TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply] {
        &self.frozen_supply
    }

    // optional uint32 trx_num = 6;

    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()
    }

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

    pub fn get_trx_num(&self) -> u32 {
        self.trx_num.unwrap_or(0)
    }

    // optional uint32 num = 7;

    pub fn clear_num(&mut self) {
        self.num = ::std::option::Option::None;
    }

    pub fn has_num(&self) -> bool {
        self.num.is_some()
    }

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

    pub fn get_num(&self) -> u32 {
        self.num.unwrap_or(0)
    }

    // optional uint64 start_time = 8;

    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()
    }

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

    pub fn get_start_time(&self) -> u64 {
        self.start_time.unwrap_or(0)
    }

    // optional uint64 end_time = 9;

    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()
    }

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

    pub fn get_end_time(&self) -> u64 {
        self.end_time.unwrap_or(0)
    }

    // optional string description = 10;

    pub fn clear_description(&mut self) {
        self.description.clear();
    }

    pub fn has_description(&self) -> bool {
        self.description.is_some()
    }

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

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

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

    pub fn get_description(&self) -> &str {
        match self.description.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional string url = 11;

    pub fn clear_url(&mut self) {
        self.url.clear();
    }

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

    pub fn get_url(&self) -> &str {
        match self.url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronAssetIssueContract>(
                    "TronSignTx_TronContract_TronAssetIssueContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronAssetIssueContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronAssetIssueContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronAssetIssueContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronAssetIssueContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronAssetIssueContract {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_abbr();
        self.clear_total_supply();
        self.clear_frozen_supply();
        self.clear_trx_num();
        self.clear_num();
        self.clear_start_time();
        self.clear_end_time();
        self.clear_description();
        self.clear_url();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
    // message fields
    frozen_amount: ::std::option::Option<u64>,
    frozen_days: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional uint64 frozen_amount = 1;

    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()
    }

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

    pub fn get_frozen_amount(&self) -> u64 {
        self.frozen_amount.unwrap_or(0)
    }

    // optional uint64 frozen_days = 2;

    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()
    }

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

    pub fn get_frozen_days(&self) -> u64 {
        self.frozen_days.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply>(
                    "TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronAssetIssueContract_TronFrozenSupply {
    fn clear(&mut self) {
        self.clear_frozen_amount();
        self.clear_frozen_days();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronParticipateAssetIssueContract {
    // message fields
    to_address: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    asset_name: ::protobuf::SingularField<::std::string::String>,
    amount: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional bytes to_address = 1;

    pub fn clear_to_address(&mut self) {
        self.to_address.clear();
    }

    pub fn has_to_address(&self) -> bool {
        self.to_address.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

    // Take field
    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_to_address(&self) -> &[u8] {
        match self.to_address.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }

    // optional string asset_name = 2;

    pub fn clear_asset_name(&mut self) {
        self.asset_name.clear();
    }

    pub fn has_asset_name(&self) -> bool {
        self.asset_name.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_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()
    }

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

    pub fn get_asset_name(&self) -> &str {
        match self.asset_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional uint64 amount = 3;

    pub fn clear_amount(&mut self) {
        self.amount = ::std::option::Option::None;
    }

    pub fn has_amount(&self) -> bool {
        self.amount.is_some()
    }

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

    pub fn get_amount(&self) -> u64 {
        self.amount.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronParticipateAssetIssueContract>(
                    "TronSignTx_TronContract_TronParticipateAssetIssueContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronParticipateAssetIssueContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronParticipateAssetIssueContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronParticipateAssetIssueContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronParticipateAssetIssueContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronParticipateAssetIssueContract {
    fn clear(&mut self) {
        self.clear_to_address();
        self.clear_asset_name();
        self.clear_amount();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronFreezeBalanceContract {
    // message fields
    frozen_balance: ::std::option::Option<u64>,
    frozen_duration: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional uint64 frozen_balance = 1;

    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()
    }

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

    pub fn get_frozen_balance(&self) -> u64 {
        self.frozen_balance.unwrap_or(0)
    }

    // optional uint64 frozen_duration = 2;

    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()
    }

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

    pub fn get_frozen_duration(&self) -> u64 {
        self.frozen_duration.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronFreezeBalanceContract>(
                    "TronSignTx_TronContract_TronFreezeBalanceContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronFreezeBalanceContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronFreezeBalanceContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronFreezeBalanceContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronFreezeBalanceContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronFreezeBalanceContract {
    fn clear(&mut self) {
        self.clear_frozen_balance();
        self.clear_frozen_duration();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUnfreezeBalanceContract {
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<TronSignTx_TronContract_TronUnfreezeBalanceContract>(
                    "TronSignTx_TronContract_TronUnfreezeBalanceContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronUnfreezeBalanceContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronUnfreezeBalanceContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronUnfreezeBalanceContract,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUnfreezeAssetContract {
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<TronSignTx_TronContract_TronUnfreezeAssetContract>(
                    "TronSignTx_TronContract_TronUnfreezeAssetContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronUnfreezeAssetContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronUnfreezeAssetContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronUnfreezeAssetContract,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronWithdrawBalanceContract {
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<TronSignTx_TronContract_TronWithdrawBalanceContract>(
                    "TronSignTx_TronContract_TronWithdrawBalanceContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronWithdrawBalanceContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronWithdrawBalanceContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronWithdrawBalanceContract,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronUpdateAssetContract {
    // message fields
    description: ::protobuf::SingularField<::std::string::String>,
    url: ::protobuf::SingularField<::std::string::String>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional string description = 1;

    pub fn clear_description(&mut self) {
        self.description.clear();
    }

    pub fn has_description(&self) -> bool {
        self.description.is_some()
    }

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

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

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

    pub fn get_description(&self) -> &str {
        match self.description.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }

    // optional string url = 2;

    pub fn clear_url(&mut self) {
        self.url.clear();
    }

    pub fn has_url(&self) -> bool {
        self.url.is_some()
    }

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

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

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

    pub fn get_url(&self) -> &str {
        match self.url.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronUpdateAssetContract>(
                    "TronSignTx_TronContract_TronUpdateAssetContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronUpdateAssetContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronUpdateAssetContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronUpdateAssetContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronUpdateAssetContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronUpdateAssetContract {
    fn clear(&mut self) {
        self.clear_description();
        self.clear_url();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalCreateContract {
    // message fields
    parameters: ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // repeated .TronSignTx.TronContract.TronProposalCreateContract.TronProposalParameters parameters = 1;

    pub fn clear_parameters(&mut self) {
        self.parameters.clear();
    }

    // Param is passed by value, moved
    pub fn set_parameters(&mut self, v: ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>) {
        self.parameters = v;
    }

    // Mutable pointer to the field.
    pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> {
        &mut self.parameters
    }

    // Take field
    pub fn take_parameters(&mut self) -> ::protobuf::RepeatedField<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> {
        ::std::mem::replace(&mut self.parameters, ::protobuf::RepeatedField::new())
    }

    pub fn get_parameters(&self) -> &[TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters] {
        &self.parameters
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronProposalCreateContract>(
                    "TronSignTx_TronContract_TronProposalCreateContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronProposalCreateContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronProposalCreateContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronProposalCreateContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronProposalCreateContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalCreateContract {
    fn clear(&mut self) {
        self.clear_parameters();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
    // message fields
    key: ::std::option::Option<u64>,
    value: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional uint64 key = 1;

    pub fn clear_key(&mut self) {
        self.key = ::std::option::Option::None;
    }

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

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

    pub fn get_key(&self) -> u64 {
        self.key.unwrap_or(0)
    }

    // optional uint64 value = 2;

    pub fn clear_value(&mut self) {
        self.value = ::std::option::Option::None;
    }

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

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

    pub fn get_value(&self) -> u64 {
        self.value.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters>(
                    "TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalCreateContract_TronProposalParameters {
    fn clear(&mut self) {
        self.clear_key();
        self.clear_value();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalApproveContract {
    // message fields
    proposal_id: ::std::option::Option<u64>,
    is_add_approval: ::std::option::Option<bool>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional uint64 proposal_id = 1;

    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()
    }

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

    pub fn get_proposal_id(&self) -> u64 {
        self.proposal_id.unwrap_or(0)
    }

    // optional bool is_add_approval = 2;

    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()
    }

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

    pub fn get_is_add_approval(&self) -> bool {
        self.is_add_approval.unwrap_or(false)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronProposalApproveContract>(
                    "TronSignTx_TronContract_TronProposalApproveContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronProposalApproveContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronProposalApproveContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronProposalApproveContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronProposalApproveContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalApproveContract {
    fn clear(&mut self) {
        self.clear_proposal_id();
        self.clear_is_add_approval();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TronSignTx_TronContract_TronProposalDeleteContract {
    // message fields
    proposal_id: ::std::option::Option<u64>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // optional uint64 proposal_id = 1;

    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()
    }

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

    pub fn get_proposal_id(&self) -> u64 {
        self.proposal_id.unwrap_or(0)
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignTx_TronContract_TronProposalDeleteContract>(
                    "TronSignTx_TronContract_TronProposalDeleteContract",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignTx_TronContract_TronProposalDeleteContract {
        static mut instance: ::protobuf::lazy::Lazy<TronSignTx_TronContract_TronProposalDeleteContract> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignTx_TronContract_TronProposalDeleteContract,
        };
        unsafe {
            instance.get(TronSignTx_TronContract_TronProposalDeleteContract::new)
        }
    }
}

impl ::protobuf::Clear for TronSignTx_TronContract_TronProposalDeleteContract {
    fn clear(&mut self) {
        self.clear_proposal_id();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

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

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

    // optional bytes signature = 1;

    pub fn clear_signature(&mut self) {
        self.signature.clear();
    }

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

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

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

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

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

    // optional bytes serialized_tx = 2;

    pub fn clear_serialized_tx(&mut self) {
        self.serialized_tx.clear();
    }

    pub fn has_serialized_tx(&self) -> bool {
        self.serialized_tx.is_some()
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_serialized_tx(&mut self) -> ::std::vec::Vec<u8> {
        self.serialized_tx.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 => &[],
        }
    }
}

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(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<TronSignedTx>(
                    "TronSignedTx",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TronSignedTx {
        static mut instance: ::protobuf::lazy::Lazy<TronSignedTx> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TronSignedTx,
        };
        unsafe {
            instance.get(TronSignedTx::new)
        }
    }
}

impl ::protobuf::Clear for TronSignedTx {
    fn clear(&mut self) {
        self.clear_signature();
        self.clear_serialized_tx();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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 mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
    lock: ::protobuf::lazy::ONCE_INIT,
    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};

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

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