anychain-tron 0.2.7

// This file is generated by rust-protobuf 3.3.0. Do not edit
// .proto file is parsed by protoc --rust-out=...
// @generated

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

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `core/contract/balance_contract.proto`

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

// @@protoc_insertion_point(message:protocol.FreezeBalanceContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FreezeBalanceContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.FreezeBalanceContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceContract.frozen_balance)
    pub frozen_balance: i64,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceContract.frozen_duration)
    pub frozen_duration: i64,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceContract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceContract.receiver_address)
    pub receiver_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.FreezeBalanceContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(5);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &FreezeBalanceContract| { &m.owner_address },
            |m: &mut FreezeBalanceContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "frozen_balance",
            |m: &FreezeBalanceContract| { &m.frozen_balance },
            |m: &mut FreezeBalanceContract| { &mut m.frozen_balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "frozen_duration",
            |m: &FreezeBalanceContract| { &m.frozen_duration },
            |m: &mut FreezeBalanceContract| { &mut m.frozen_duration },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &FreezeBalanceContract| { &m.resource },
            |m: &mut FreezeBalanceContract| { &mut m.resource },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "receiver_address",
            |m: &FreezeBalanceContract| { &m.receiver_address },
            |m: &mut FreezeBalanceContract| { &mut m.receiver_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FreezeBalanceContract>(
            "FreezeBalanceContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for FreezeBalanceContract {
    const NAME: &'static str = "FreezeBalanceContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                16 => {
                    self.frozen_balance = is.read_int64()?;
                },
                24 => {
                    self.frozen_duration = is.read_int64()?;
                },
                80 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                122 => {
                    self.receiver_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.frozen_balance != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.frozen_balance);
        }
        if self.frozen_duration != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.frozen_duration);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(10, self.resource.value());
        }
        if !self.receiver_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(15, &self.receiver_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.frozen_balance != 0 {
            os.write_int64(2, self.frozen_balance)?;
        }
        if self.frozen_duration != 0 {
            os.write_int64(3, self.frozen_duration)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(10, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        if !self.receiver_address.is_empty() {
            os.write_bytes(15, &self.receiver_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.frozen_balance = 0;
        self.frozen_duration = 0;
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.receiver_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FreezeBalanceContract {
        static instance: FreezeBalanceContract = FreezeBalanceContract {
            owner_address: ::std::vec::Vec::new(),
            frozen_balance: 0,
            frozen_duration: 0,
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            receiver_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FreezeBalanceContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("FreezeBalanceContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for FreezeBalanceContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.UnfreezeBalanceContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct UnfreezeBalanceContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceContract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceContract.receiver_address)
    pub receiver_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.UnfreezeBalanceContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &UnfreezeBalanceContract| { &m.owner_address },
            |m: &mut UnfreezeBalanceContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &UnfreezeBalanceContract| { &m.resource },
            |m: &mut UnfreezeBalanceContract| { &mut m.resource },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "receiver_address",
            |m: &UnfreezeBalanceContract| { &m.receiver_address },
            |m: &mut UnfreezeBalanceContract| { &mut m.receiver_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnfreezeBalanceContract>(
            "UnfreezeBalanceContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UnfreezeBalanceContract {
    const NAME: &'static str = "UnfreezeBalanceContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                80 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                122 => {
                    self.receiver_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(10, self.resource.value());
        }
        if !self.receiver_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(15, &self.receiver_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(10, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        if !self.receiver_address.is_empty() {
            os.write_bytes(15, &self.receiver_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.receiver_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UnfreezeBalanceContract {
        static instance: UnfreezeBalanceContract = UnfreezeBalanceContract {
            owner_address: ::std::vec::Vec::new(),
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            receiver_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UnfreezeBalanceContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnfreezeBalanceContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UnfreezeBalanceContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.WithdrawBalanceContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct WithdrawBalanceContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.WithdrawBalanceContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.WithdrawBalanceContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &WithdrawBalanceContract| { &m.owner_address },
            |m: &mut WithdrawBalanceContract| { &mut m.owner_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<WithdrawBalanceContract>(
            "WithdrawBalanceContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for WithdrawBalanceContract {
    const NAME: &'static str = "WithdrawBalanceContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static WithdrawBalanceContract {
        static instance: WithdrawBalanceContract = WithdrawBalanceContract {
            owner_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for WithdrawBalanceContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("WithdrawBalanceContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for WithdrawBalanceContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.TransferContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TransferContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.TransferContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.TransferContract.to_address)
    pub to_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.TransferContract.amount)
    pub amount: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.TransferContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &TransferContract| { &m.owner_address },
            |m: &mut TransferContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "to_address",
            |m: &TransferContract| { &m.to_address },
            |m: &mut TransferContract| { &mut m.to_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "amount",
            |m: &TransferContract| { &m.amount },
            |m: &mut TransferContract| { &mut m.amount },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TransferContract>(
            "TransferContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for TransferContract {
    const NAME: &'static str = "TransferContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                18 => {
                    self.to_address = is.read_bytes()?;
                },
                24 => {
                    self.amount = is.read_int64()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if !self.to_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.to_address);
        }
        if self.amount != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.amount);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if !self.to_address.is_empty() {
            os.write_bytes(2, &self.to_address)?;
        }
        if self.amount != 0 {
            os.write_int64(3, self.amount)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.to_address.clear();
        self.amount = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TransferContract {
        static instance: TransferContract = TransferContract {
            owner_address: ::std::vec::Vec::new(),
            to_address: ::std::vec::Vec::new(),
            amount: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TransferContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TransferContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for TransferContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.TransactionBalanceTrace)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TransactionBalanceTrace {
    // message fields
    // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.transaction_identifier)
    pub transaction_identifier: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.operation)
    pub operation: ::std::vec::Vec<transaction_balance_trace::Operation>,
    // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.type)
    pub type_: ::std::string::String,
    // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.status)
    pub status: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.TransactionBalanceTrace.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "transaction_identifier",
            |m: &TransactionBalanceTrace| { &m.transaction_identifier },
            |m: &mut TransactionBalanceTrace| { &mut m.transaction_identifier },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "operation",
            |m: &TransactionBalanceTrace| { &m.operation },
            |m: &mut TransactionBalanceTrace| { &mut m.operation },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "type",
            |m: &TransactionBalanceTrace| { &m.type_ },
            |m: &mut TransactionBalanceTrace| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "status",
            |m: &TransactionBalanceTrace| { &m.status },
            |m: &mut TransactionBalanceTrace| { &mut m.status },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TransactionBalanceTrace>(
            "TransactionBalanceTrace",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for TransactionBalanceTrace {
    const NAME: &'static str = "TransactionBalanceTrace";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.transaction_identifier = is.read_bytes()?;
                },
                18 => {
                    self.operation.push(is.read_message()?);
                },
                26 => {
                    self.type_ = is.read_string()?;
                },
                34 => {
                    self.status = is.read_string()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.transaction_identifier.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.transaction_identifier);
        }
        for value in &self.operation {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if !self.type_.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.type_);
        }
        if !self.status.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.status);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.transaction_identifier.is_empty() {
            os.write_bytes(1, &self.transaction_identifier)?;
        }
        for v in &self.operation {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if !self.type_.is_empty() {
            os.write_string(3, &self.type_)?;
        }
        if !self.status.is_empty() {
            os.write_string(4, &self.status)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.transaction_identifier.clear();
        self.operation.clear();
        self.type_.clear();
        self.status.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TransactionBalanceTrace {
        static instance: TransactionBalanceTrace = TransactionBalanceTrace {
            transaction_identifier: ::std::vec::Vec::new(),
            operation: ::std::vec::Vec::new(),
            type_: ::std::string::String::new(),
            status: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TransactionBalanceTrace {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TransactionBalanceTrace").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for TransactionBalanceTrace {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `TransactionBalanceTrace`
pub mod transaction_balance_trace {
    // @@protoc_insertion_point(message:protocol.TransactionBalanceTrace.Operation)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Operation {
        // message fields
        // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.Operation.operation_identifier)
        pub operation_identifier: i64,
        // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.Operation.address)
        pub address: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:protocol.TransactionBalanceTrace.Operation.amount)
        pub amount: i64,
        // special fields
        // @@protoc_insertion_point(special_field:protocol.TransactionBalanceTrace.Operation.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(3);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "operation_identifier",
                |m: &Operation| { &m.operation_identifier },
                |m: &mut Operation| { &mut m.operation_identifier },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "address",
                |m: &Operation| { &m.address },
                |m: &mut Operation| { &mut m.address },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "amount",
                |m: &Operation| { &m.amount },
                |m: &mut Operation| { &mut m.amount },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Operation>(
                "TransactionBalanceTrace.Operation",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Operation {
        const NAME: &'static str = "Operation";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.operation_identifier = is.read_int64()?;
                    },
                    18 => {
                        self.address = is.read_bytes()?;
                    },
                    24 => {
                        self.amount = is.read_int64()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.operation_identifier != 0 {
                my_size += ::protobuf::rt::int64_size(1, self.operation_identifier);
            }
            if !self.address.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.address);
            }
            if self.amount != 0 {
                my_size += ::protobuf::rt::int64_size(3, self.amount);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.operation_identifier != 0 {
                os.write_int64(1, self.operation_identifier)?;
            }
            if !self.address.is_empty() {
                os.write_bytes(2, &self.address)?;
            }
            if self.amount != 0 {
                os.write_int64(3, self.amount)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.operation_identifier = 0;
            self.address.clear();
            self.amount = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Operation {
            static instance: Operation = Operation {
                operation_identifier: 0,
                address: ::std::vec::Vec::new(),
                amount: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Operation {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("TransactionBalanceTrace.Operation").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Operation {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }
}

// @@protoc_insertion_point(message:protocol.BlockBalanceTrace)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct BlockBalanceTrace {
    // message fields
    // @@protoc_insertion_point(field:protocol.BlockBalanceTrace.block_identifier)
    pub block_identifier: ::protobuf::MessageField<block_balance_trace::BlockIdentifier>,
    // @@protoc_insertion_point(field:protocol.BlockBalanceTrace.timestamp)
    pub timestamp: i64,
    // @@protoc_insertion_point(field:protocol.BlockBalanceTrace.transaction_balance_trace)
    pub transaction_balance_trace: ::std::vec::Vec<TransactionBalanceTrace>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.BlockBalanceTrace.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, block_balance_trace::BlockIdentifier>(
            "block_identifier",
            |m: &BlockBalanceTrace| { &m.block_identifier },
            |m: &mut BlockBalanceTrace| { &mut m.block_identifier },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "timestamp",
            |m: &BlockBalanceTrace| { &m.timestamp },
            |m: &mut BlockBalanceTrace| { &mut m.timestamp },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "transaction_balance_trace",
            |m: &BlockBalanceTrace| { &m.transaction_balance_trace },
            |m: &mut BlockBalanceTrace| { &mut m.transaction_balance_trace },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BlockBalanceTrace>(
            "BlockBalanceTrace",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for BlockBalanceTrace {
    const NAME: &'static str = "BlockBalanceTrace";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.block_identifier)?;
                },
                16 => {
                    self.timestamp = is.read_int64()?;
                },
                26 => {
                    self.transaction_balance_trace.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.block_identifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.timestamp);
        }
        for value in &self.transaction_balance_trace {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.block_identifier.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if self.timestamp != 0 {
            os.write_int64(2, self.timestamp)?;
        }
        for v in &self.transaction_balance_trace {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.block_identifier.clear();
        self.timestamp = 0;
        self.transaction_balance_trace.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static BlockBalanceTrace {
        static instance: BlockBalanceTrace = BlockBalanceTrace {
            block_identifier: ::protobuf::MessageField::none(),
            timestamp: 0,
            transaction_balance_trace: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for BlockBalanceTrace {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("BlockBalanceTrace").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for BlockBalanceTrace {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `BlockBalanceTrace`
pub mod block_balance_trace {
    // @@protoc_insertion_point(message:protocol.BlockBalanceTrace.BlockIdentifier)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct BlockIdentifier {
        // message fields
        // @@protoc_insertion_point(field:protocol.BlockBalanceTrace.BlockIdentifier.hash)
        pub hash: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:protocol.BlockBalanceTrace.BlockIdentifier.number)
        pub number: i64,
        // special fields
        // @@protoc_insertion_point(special_field:protocol.BlockBalanceTrace.BlockIdentifier.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "hash",
                |m: &BlockIdentifier| { &m.hash },
                |m: &mut BlockIdentifier| { &mut m.hash },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "number",
                |m: &BlockIdentifier| { &m.number },
                |m: &mut BlockIdentifier| { &mut m.number },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BlockIdentifier>(
                "BlockBalanceTrace.BlockIdentifier",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for BlockIdentifier {
        const NAME: &'static str = "BlockIdentifier";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.hash = is.read_bytes()?;
                    },
                    16 => {
                        self.number = is.read_int64()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.hash.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.hash);
            }
            if self.number != 0 {
                my_size += ::protobuf::rt::int64_size(2, self.number);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.hash.is_empty() {
                os.write_bytes(1, &self.hash)?;
            }
            if self.number != 0 {
                os.write_int64(2, self.number)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.hash.clear();
            self.number = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static BlockIdentifier {
            static instance: BlockIdentifier = BlockIdentifier {
                hash: ::std::vec::Vec::new(),
                number: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for BlockIdentifier {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("BlockBalanceTrace.BlockIdentifier").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for BlockIdentifier {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }
}

// @@protoc_insertion_point(message:protocol.AccountTrace)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AccountTrace {
    // message fields
    // @@protoc_insertion_point(field:protocol.AccountTrace.balance)
    pub balance: i64,
    // @@protoc_insertion_point(field:protocol.AccountTrace.placeholder)
    pub placeholder: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.AccountTrace.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "balance",
            |m: &AccountTrace| { &m.balance },
            |m: &mut AccountTrace| { &mut m.balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "placeholder",
            |m: &AccountTrace| { &m.placeholder },
            |m: &mut AccountTrace| { &mut m.placeholder },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AccountTrace>(
            "AccountTrace",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AccountTrace {
    const NAME: &'static str = "AccountTrace";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.balance = is.read_int64()?;
                },
                792 => {
                    self.placeholder = is.read_int64()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.balance != 0 {
            my_size += ::protobuf::rt::int64_size(1, self.balance);
        }
        if self.placeholder != 0 {
            my_size += ::protobuf::rt::int64_size(99, self.placeholder);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.balance != 0 {
            os.write_int64(1, self.balance)?;
        }
        if self.placeholder != 0 {
            os.write_int64(99, self.placeholder)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.balance = 0;
        self.placeholder = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AccountTrace {
        static instance: AccountTrace = AccountTrace {
            balance: 0,
            placeholder: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AccountTrace {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AccountTrace").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AccountTrace {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.AccountIdentifier)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AccountIdentifier {
    // message fields
    // @@protoc_insertion_point(field:protocol.AccountIdentifier.address)
    pub address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.AccountIdentifier.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "address",
            |m: &AccountIdentifier| { &m.address },
            |m: &mut AccountIdentifier| { &mut m.address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AccountIdentifier>(
            "AccountIdentifier",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AccountIdentifier {
    const NAME: &'static str = "AccountIdentifier";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.address.is_empty() {
            os.write_bytes(1, &self.address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

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

    fn default_instance() -> &'static AccountIdentifier {
        static instance: AccountIdentifier = AccountIdentifier {
            address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AccountIdentifier {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AccountIdentifier").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AccountIdentifier {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.AccountBalanceRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AccountBalanceRequest {
    // message fields
    // @@protoc_insertion_point(field:protocol.AccountBalanceRequest.account_identifier)
    pub account_identifier: ::protobuf::MessageField<AccountIdentifier>,
    // @@protoc_insertion_point(field:protocol.AccountBalanceRequest.block_identifier)
    pub block_identifier: ::protobuf::MessageField<block_balance_trace::BlockIdentifier>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.AccountBalanceRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, AccountIdentifier>(
            "account_identifier",
            |m: &AccountBalanceRequest| { &m.account_identifier },
            |m: &mut AccountBalanceRequest| { &mut m.account_identifier },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, block_balance_trace::BlockIdentifier>(
            "block_identifier",
            |m: &AccountBalanceRequest| { &m.block_identifier },
            |m: &mut AccountBalanceRequest| { &mut m.block_identifier },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AccountBalanceRequest>(
            "AccountBalanceRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AccountBalanceRequest {
    const NAME: &'static str = "AccountBalanceRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.account_identifier)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.block_identifier)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.account_identifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.block_identifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.account_identifier.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.block_identifier.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.account_identifier.clear();
        self.block_identifier.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AccountBalanceRequest {
        static instance: AccountBalanceRequest = AccountBalanceRequest {
            account_identifier: ::protobuf::MessageField::none(),
            block_identifier: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AccountBalanceRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AccountBalanceRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AccountBalanceRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.AccountBalanceResponse)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AccountBalanceResponse {
    // message fields
    // @@protoc_insertion_point(field:protocol.AccountBalanceResponse.balance)
    pub balance: i64,
    // @@protoc_insertion_point(field:protocol.AccountBalanceResponse.block_identifier)
    pub block_identifier: ::protobuf::MessageField<block_balance_trace::BlockIdentifier>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.AccountBalanceResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "balance",
            |m: &AccountBalanceResponse| { &m.balance },
            |m: &mut AccountBalanceResponse| { &mut m.balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, block_balance_trace::BlockIdentifier>(
            "block_identifier",
            |m: &AccountBalanceResponse| { &m.block_identifier },
            |m: &mut AccountBalanceResponse| { &mut m.block_identifier },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AccountBalanceResponse>(
            "AccountBalanceResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AccountBalanceResponse {
    const NAME: &'static str = "AccountBalanceResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.balance = is.read_int64()?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.block_identifier)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.balance != 0 {
            my_size += ::protobuf::rt::int64_size(1, self.balance);
        }
        if let Some(v) = self.block_identifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.balance != 0 {
            os.write_int64(1, self.balance)?;
        }
        if let Some(v) = self.block_identifier.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.balance = 0;
        self.block_identifier.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AccountBalanceResponse {
        static instance: AccountBalanceResponse = AccountBalanceResponse {
            balance: 0,
            block_identifier: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AccountBalanceResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AccountBalanceResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for AccountBalanceResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.FreezeBalanceV2Contract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FreezeBalanceV2Contract {
    // message fields
    // @@protoc_insertion_point(field:protocol.FreezeBalanceV2Contract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceV2Contract.frozen_balance)
    pub frozen_balance: i64,
    // @@protoc_insertion_point(field:protocol.FreezeBalanceV2Contract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.FreezeBalanceV2Contract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &FreezeBalanceV2Contract| { &m.owner_address },
            |m: &mut FreezeBalanceV2Contract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "frozen_balance",
            |m: &FreezeBalanceV2Contract| { &m.frozen_balance },
            |m: &mut FreezeBalanceV2Contract| { &mut m.frozen_balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &FreezeBalanceV2Contract| { &m.resource },
            |m: &mut FreezeBalanceV2Contract| { &mut m.resource },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FreezeBalanceV2Contract>(
            "FreezeBalanceV2Contract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for FreezeBalanceV2Contract {
    const NAME: &'static str = "FreezeBalanceV2Contract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                16 => {
                    self.frozen_balance = is.read_int64()?;
                },
                24 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.frozen_balance != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.frozen_balance);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(3, self.resource.value());
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.frozen_balance != 0 {
            os.write_int64(2, self.frozen_balance)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.frozen_balance = 0;
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FreezeBalanceV2Contract {
        static instance: FreezeBalanceV2Contract = FreezeBalanceV2Contract {
            owner_address: ::std::vec::Vec::new(),
            frozen_balance: 0,
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FreezeBalanceV2Contract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("FreezeBalanceV2Contract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for FreezeBalanceV2Contract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.UnfreezeBalanceV2Contract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct UnfreezeBalanceV2Contract {
    // message fields
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceV2Contract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceV2Contract.unfreeze_balance)
    pub unfreeze_balance: i64,
    // @@protoc_insertion_point(field:protocol.UnfreezeBalanceV2Contract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.UnfreezeBalanceV2Contract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &UnfreezeBalanceV2Contract| { &m.owner_address },
            |m: &mut UnfreezeBalanceV2Contract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "unfreeze_balance",
            |m: &UnfreezeBalanceV2Contract| { &m.unfreeze_balance },
            |m: &mut UnfreezeBalanceV2Contract| { &mut m.unfreeze_balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &UnfreezeBalanceV2Contract| { &m.resource },
            |m: &mut UnfreezeBalanceV2Contract| { &mut m.resource },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnfreezeBalanceV2Contract>(
            "UnfreezeBalanceV2Contract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UnfreezeBalanceV2Contract {
    const NAME: &'static str = "UnfreezeBalanceV2Contract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                16 => {
                    self.unfreeze_balance = is.read_int64()?;
                },
                24 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.unfreeze_balance != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.unfreeze_balance);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(3, self.resource.value());
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.unfreeze_balance != 0 {
            os.write_int64(2, self.unfreeze_balance)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.unfreeze_balance = 0;
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UnfreezeBalanceV2Contract {
        static instance: UnfreezeBalanceV2Contract = UnfreezeBalanceV2Contract {
            owner_address: ::std::vec::Vec::new(),
            unfreeze_balance: 0,
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UnfreezeBalanceV2Contract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnfreezeBalanceV2Contract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UnfreezeBalanceV2Contract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.WithdrawExpireUnfreezeContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct WithdrawExpireUnfreezeContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.WithdrawExpireUnfreezeContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.WithdrawExpireUnfreezeContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &WithdrawExpireUnfreezeContract| { &m.owner_address },
            |m: &mut WithdrawExpireUnfreezeContract| { &mut m.owner_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<WithdrawExpireUnfreezeContract>(
            "WithdrawExpireUnfreezeContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for WithdrawExpireUnfreezeContract {
    const NAME: &'static str = "WithdrawExpireUnfreezeContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static WithdrawExpireUnfreezeContract {
        static instance: WithdrawExpireUnfreezeContract = WithdrawExpireUnfreezeContract {
            owner_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for WithdrawExpireUnfreezeContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("WithdrawExpireUnfreezeContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for WithdrawExpireUnfreezeContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.DelegateResourceContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DelegateResourceContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.balance)
    pub balance: i64,
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.receiver_address)
    pub receiver_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.lock)
    pub lock: bool,
    // @@protoc_insertion_point(field:protocol.DelegateResourceContract.lock_period)
    pub lock_period: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.DelegateResourceContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &DelegateResourceContract| { &m.owner_address },
            |m: &mut DelegateResourceContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &DelegateResourceContract| { &m.resource },
            |m: &mut DelegateResourceContract| { &mut m.resource },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "balance",
            |m: &DelegateResourceContract| { &m.balance },
            |m: &mut DelegateResourceContract| { &mut m.balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "receiver_address",
            |m: &DelegateResourceContract| { &m.receiver_address },
            |m: &mut DelegateResourceContract| { &mut m.receiver_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "lock",
            |m: &DelegateResourceContract| { &m.lock },
            |m: &mut DelegateResourceContract| { &mut m.lock },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "lock_period",
            |m: &DelegateResourceContract| { &m.lock_period },
            |m: &mut DelegateResourceContract| { &mut m.lock_period },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DelegateResourceContract>(
            "DelegateResourceContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for DelegateResourceContract {
    const NAME: &'static str = "DelegateResourceContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                16 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                24 => {
                    self.balance = is.read_int64()?;
                },
                34 => {
                    self.receiver_address = is.read_bytes()?;
                },
                40 => {
                    self.lock = is.read_bool()?;
                },
                48 => {
                    self.lock_period = is.read_int64()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(2, self.resource.value());
        }
        if self.balance != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.balance);
        }
        if !self.receiver_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.receiver_address);
        }
        if self.lock != false {
            my_size += 1 + 1;
        }
        if self.lock_period != 0 {
            my_size += ::protobuf::rt::int64_size(6, self.lock_period);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        if self.balance != 0 {
            os.write_int64(3, self.balance)?;
        }
        if !self.receiver_address.is_empty() {
            os.write_bytes(4, &self.receiver_address)?;
        }
        if self.lock != false {
            os.write_bool(5, self.lock)?;
        }
        if self.lock_period != 0 {
            os.write_int64(6, self.lock_period)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.balance = 0;
        self.receiver_address.clear();
        self.lock = false;
        self.lock_period = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DelegateResourceContract {
        static instance: DelegateResourceContract = DelegateResourceContract {
            owner_address: ::std::vec::Vec::new(),
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            balance: 0,
            receiver_address: ::std::vec::Vec::new(),
            lock: false,
            lock_period: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DelegateResourceContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("DelegateResourceContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for DelegateResourceContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.UnDelegateResourceContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct UnDelegateResourceContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.UnDelegateResourceContract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.UnDelegateResourceContract.resource)
    pub resource: ::protobuf::EnumOrUnknown<super::common::ResourceCode>,
    // @@protoc_insertion_point(field:protocol.UnDelegateResourceContract.balance)
    pub balance: i64,
    // @@protoc_insertion_point(field:protocol.UnDelegateResourceContract.receiver_address)
    pub receiver_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.UnDelegateResourceContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &UnDelegateResourceContract| { &m.owner_address },
            |m: &mut UnDelegateResourceContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "resource",
            |m: &UnDelegateResourceContract| { &m.resource },
            |m: &mut UnDelegateResourceContract| { &mut m.resource },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "balance",
            |m: &UnDelegateResourceContract| { &m.balance },
            |m: &mut UnDelegateResourceContract| { &mut m.balance },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "receiver_address",
            |m: &UnDelegateResourceContract| { &m.receiver_address },
            |m: &mut UnDelegateResourceContract| { &mut m.receiver_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnDelegateResourceContract>(
            "UnDelegateResourceContract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for UnDelegateResourceContract {
    const NAME: &'static str = "UnDelegateResourceContract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                16 => {
                    self.resource = is.read_enum_or_unknown()?;
                },
                24 => {
                    self.balance = is.read_int64()?;
                },
                34 => {
                    self.receiver_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            my_size += ::protobuf::rt::int32_size(2, self.resource.value());
        }
        if self.balance != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.balance);
        }
        if !self.receiver_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.receiver_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        if self.resource != ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.resource))?;
        }
        if self.balance != 0 {
            os.write_int64(3, self.balance)?;
        }
        if !self.receiver_address.is_empty() {
            os.write_bytes(4, &self.receiver_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.resource = ::protobuf::EnumOrUnknown::new(super::common::ResourceCode::BANDWIDTH);
        self.balance = 0;
        self.receiver_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static UnDelegateResourceContract {
        static instance: UnDelegateResourceContract = UnDelegateResourceContract {
            owner_address: ::std::vec::Vec::new(),
            resource: ::protobuf::EnumOrUnknown::from_i32(0),
            balance: 0,
            receiver_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for UnDelegateResourceContract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnDelegateResourceContract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for UnDelegateResourceContract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:protocol.CancelAllUnfreezeV2Contract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CancelAllUnfreezeV2Contract {
    // message fields
    // @@protoc_insertion_point(field:protocol.CancelAllUnfreezeV2Contract.owner_address)
    pub owner_address: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.CancelAllUnfreezeV2Contract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "owner_address",
            |m: &CancelAllUnfreezeV2Contract| { &m.owner_address },
            |m: &mut CancelAllUnfreezeV2Contract| { &mut m.owner_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CancelAllUnfreezeV2Contract>(
            "CancelAllUnfreezeV2Contract",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for CancelAllUnfreezeV2Contract {
    const NAME: &'static str = "CancelAllUnfreezeV2Contract";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.owner_address = is.read_bytes()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.owner_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.owner_address.is_empty() {
            os.write_bytes(1, &self.owner_address)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.owner_address.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CancelAllUnfreezeV2Contract {
        static instance: CancelAllUnfreezeV2Contract = CancelAllUnfreezeV2Contract {
            owner_address: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for CancelAllUnfreezeV2Contract {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("CancelAllUnfreezeV2Contract").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CancelAllUnfreezeV2Contract {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n$core/contract/balance_contract.proto\x12\x08protocol\x1a\x1acore/cont\
    ract/common.proto\"\xeb\x01\n\x15FreezeBalanceContract\x12#\n\rowner_add\
    ress\x18\x01\x20\x01(\x0cR\x0cownerAddress\x12%\n\x0efrozen_balance\x18\
    \x02\x20\x01(\x03R\rfrozenBalance\x12'\n\x0ffrozen_duration\x18\x03\x20\
    \x01(\x03R\x0efrozenDuration\x122\n\x08resource\x18\n\x20\x01(\x0e2\x16.\
    protocol.ResourceCodeR\x08resource\x12)\n\x10receiver_address\x18\x0f\
    \x20\x01(\x0cR\x0freceiverAddress\"\x9d\x01\n\x17UnfreezeBalanceContract\
    \x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddress\x122\n\x08r\
    esource\x18\n\x20\x01(\x0e2\x16.protocol.ResourceCodeR\x08resource\x12)\
    \n\x10receiver_address\x18\x0f\x20\x01(\x0cR\x0freceiverAddress\">\n\x17\
    WithdrawBalanceContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0co\
    wnerAddress\"n\n\x10TransferContract\x12#\n\rowner_address\x18\x01\x20\
    \x01(\x0cR\x0cownerAddress\x12\x1d\n\nto_address\x18\x02\x20\x01(\x0cR\t\
    toAddress\x12\x16\n\x06amount\x18\x03\x20\x01(\x03R\x06amount\"\xb9\x02\
    \n\x17TransactionBalanceTrace\x125\n\x16transaction_identifier\x18\x01\
    \x20\x01(\x0cR\x15transactionIdentifier\x12I\n\toperation\x18\x02\x20\
    \x03(\x0b2+.protocol.TransactionBalanceTrace.OperationR\toperation\x12\
    \x12\n\x04type\x18\x03\x20\x01(\tR\x04type\x12\x16\n\x06status\x18\x04\
    \x20\x01(\tR\x06status\x1ap\n\tOperation\x121\n\x14operation_identifier\
    \x18\x01\x20\x01(\x03R\x13operationIdentifier\x12\x18\n\x07address\x18\
    \x02\x20\x01(\x0cR\x07address\x12\x16\n\x06amount\x18\x03\x20\x01(\x03R\
    \x06amount\"\xa7\x02\n\x11BlockBalanceTrace\x12V\n\x10block_identifier\
    \x18\x01\x20\x01(\x0b2+.protocol.BlockBalanceTrace.BlockIdentifierR\x0fb\
    lockIdentifier\x12\x1c\n\ttimestamp\x18\x02\x20\x01(\x03R\ttimestamp\x12\
    ]\n\x19transaction_balance_trace\x18\x03\x20\x03(\x0b2!.protocol.Transac\
    tionBalanceTraceR\x17transactionBalanceTrace\x1a=\n\x0fBlockIdentifier\
    \x12\x12\n\x04hash\x18\x01\x20\x01(\x0cR\x04hash\x12\x16\n\x06number\x18\
    \x02\x20\x01(\x03R\x06number\"J\n\x0cAccountTrace\x12\x18\n\x07balance\
    \x18\x01\x20\x01(\x03R\x07balance\x12\x20\n\x0bplaceholder\x18c\x20\x01(\
    \x03R\x0bplaceholder\"-\n\x11AccountIdentifier\x12\x18\n\x07address\x18\
    \x01\x20\x01(\x0cR\x07address\"\xbb\x01\n\x15AccountBalanceRequest\x12J\
    \n\x12account_identifier\x18\x01\x20\x01(\x0b2\x1b.protocol.AccountIdent\
    ifierR\x11accountIdentifier\x12V\n\x10block_identifier\x18\x02\x20\x01(\
    \x0b2+.protocol.BlockBalanceTrace.BlockIdentifierR\x0fblockIdentifier\"\
    \x8a\x01\n\x16AccountBalanceResponse\x12\x18\n\x07balance\x18\x01\x20\
    \x01(\x03R\x07balance\x12V\n\x10block_identifier\x18\x02\x20\x01(\x0b2+.\
    protocol.BlockBalanceTrace.BlockIdentifierR\x0fblockIdentifier\"\x99\x01\
    \n\x17FreezeBalanceV2Contract\x12#\n\rowner_address\x18\x01\x20\x01(\x0c\
    R\x0cownerAddress\x12%\n\x0efrozen_balance\x18\x02\x20\x01(\x03R\rfrozen\
    Balance\x122\n\x08resource\x18\x03\x20\x01(\x0e2\x16.protocol.ResourceCo\
    deR\x08resource\"\x9f\x01\n\x19UnfreezeBalanceV2Contract\x12#\n\rowner_a\
    ddress\x18\x01\x20\x01(\x0cR\x0cownerAddress\x12)\n\x10unfreeze_balance\
    \x18\x02\x20\x01(\x03R\x0funfreezeBalance\x122\n\x08resource\x18\x03\x20\
    \x01(\x0e2\x16.protocol.ResourceCodeR\x08resource\"E\n\x1eWithdrawExpire\
    UnfreezeContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAdd\
    ress\"\xed\x01\n\x18DelegateResourceContract\x12#\n\rowner_address\x18\
    \x01\x20\x01(\x0cR\x0cownerAddress\x122\n\x08resource\x18\x02\x20\x01(\
    \x0e2\x16.protocol.ResourceCodeR\x08resource\x12\x18\n\x07balance\x18\
    \x03\x20\x01(\x03R\x07balance\x12)\n\x10receiver_address\x18\x04\x20\x01\
    (\x0cR\x0freceiverAddress\x12\x12\n\x04lock\x18\x05\x20\x01(\x08R\x04loc\
    k\x12\x1f\n\x0block_period\x18\x06\x20\x01(\x03R\nlockPeriod\"\xba\x01\n\
    \x1aUnDelegateResourceContract\x12#\n\rowner_address\x18\x01\x20\x01(\
    \x0cR\x0cownerAddress\x122\n\x08resource\x18\x02\x20\x01(\x0e2\x16.proto\
    col.ResourceCodeR\x08resource\x12\x18\n\x07balance\x18\x03\x20\x01(\x03R\
    \x07balance\x12)\n\x10receiver_address\x18\x04\x20\x01(\x0cR\x0freceiver\
    Address\"B\n\x1bCancelAllUnfreezeV2Contract\x12#\n\rowner_address\x18\
    \x01\x20\x01(\x0cR\x0cownerAddressBE\n\x18org.tron.protos.contractZ)gith\
    ub.com/tronprotocol/grpc-gateway/coreJ\xb1\x1b\n\x06\x12\x04\0\0u\x01\n\
    \x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x11\n\x08\n\
    \x01\x08\x12\x03\x04\01\nH\n\x02\x08\x01\x12\x03\x04\01\"=Specify\x20the\
    \x20name\x20of\x20the\x20package\x20that\x20generated\x20the\x20Java\x20\
    file\n\n\x08\n\x01\x08\x12\x03\x06\0@\nv\n\x02\x08\x0b\x12\x03\x06\0@\
    \x1akoption\x20java_outer_classname\x20=\x20\"FreezeBalanceContract\";\
    \x20//Specify\x20the\x20class\x20name\x20of\x20the\x20generated\x20Java\
    \x20file\n\n\t\n\x02\x03\0\x12\x03\x08\0$\n\n\n\x02\x04\0\x12\x04\n\0\
    \x11\x01\n\n\n\x03\x04\0\x01\x12\x03\n\x08\x1d\n\x0b\n\x04\x04\0\x02\0\
    \x12\x03\x0b\x02\x1a\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0b\x02\x07\n\
    \x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0b\x08\x15\n\x0c\n\x05\x04\0\x02\0\
    \x03\x12\x03\x0b\x18\x19\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x0c\x02\x1b\n\
    \x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x0c\x02\x07\n\x0c\n\x05\x04\0\x02\
    \x01\x01\x12\x03\x0c\x08\x16\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x0c\
    \x19\x1a\n\x0b\n\x04\x04\0\x02\x02\x12\x03\r\x02\x1c\n\x0c\n\x05\x04\0\
    \x02\x02\x05\x12\x03\r\x02\x07\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\r\
    \x08\x17\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\r\x1a\x1b\n\x0b\n\x04\x04\
    \0\x02\x03\x12\x03\x0f\x02\x1d\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03\x0f\
    \x02\x0e\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03\x0f\x0f\x17\n\x0c\n\x05\
    \x04\0\x02\x03\x03\x12\x03\x0f\x1a\x1c\n\x0b\n\x04\x04\0\x02\x04\x12\x03\
    \x10\x02\x1e\n\x0c\n\x05\x04\0\x02\x04\x05\x12\x03\x10\x02\x07\n\x0c\n\
    \x05\x04\0\x02\x04\x01\x12\x03\x10\x08\x18\n\x0c\n\x05\x04\0\x02\x04\x03\
    \x12\x03\x10\x1b\x1d\n\n\n\x02\x04\x01\x12\x04\x14\0\x19\x01\n\n\n\x03\
    \x04\x01\x01\x12\x03\x14\x08\x1f\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x15\
    \x02\x1a\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\x15\x02\x07\n\x0c\n\x05\
    \x04\x01\x02\0\x01\x12\x03\x15\x08\x15\n\x0c\n\x05\x04\x01\x02\0\x03\x12\
    \x03\x15\x18\x19\n\x0b\n\x04\x04\x01\x02\x01\x12\x03\x17\x02\x1d\n\x0c\n\
    \x05\x04\x01\x02\x01\x06\x12\x03\x17\x02\x0e\n\x0c\n\x05\x04\x01\x02\x01\
    \x01\x12\x03\x17\x0f\x17\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\x17\x1a\
    \x1c\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x18\x02\x1e\n\x0c\n\x05\x04\x01\
    \x02\x02\x05\x12\x03\x18\x02\x07\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\
    \x18\x08\x18\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x18\x1b\x1d\n\n\n\
    \x02\x04\x02\x12\x04\x1b\0\x1d\x01\n\n\n\x03\x04\x02\x01\x12\x03\x1b\x08\
    \x1f\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x1c\x02\x1a\n\x0c\n\x05\x04\x02\
    \x02\0\x05\x12\x03\x1c\x02\x07\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x1c\
    \x08\x15\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x1c\x18\x19\n\n\n\x02\x04\
    \x03\x12\x04\x1f\0#\x01\n\n\n\x03\x04\x03\x01\x12\x03\x1f\x08\x18\n\x0b\
    \n\x04\x04\x03\x02\0\x12\x03\x20\x02\x1a\n\x0c\n\x05\x04\x03\x02\0\x05\
    \x12\x03\x20\x02\x07\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03\x20\x08\x15\n\
    \x0c\n\x05\x04\x03\x02\0\x03\x12\x03\x20\x18\x19\n\x0b\n\x04\x04\x03\x02\
    \x01\x12\x03!\x02\x17\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03!\x02\x07\n\
    \x0c\n\x05\x04\x03\x02\x01\x01\x12\x03!\x08\x12\n\x0c\n\x05\x04\x03\x02\
    \x01\x03\x12\x03!\x15\x16\n\x0b\n\x04\x04\x03\x02\x02\x12\x03\"\x02\x13\
    \n\x0c\n\x05\x04\x03\x02\x02\x05\x12\x03\"\x02\x07\n\x0c\n\x05\x04\x03\
    \x02\x02\x01\x12\x03\"\x08\x0e\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03\"\
    \x11\x12\n\n\n\x02\x04\x04\x12\x04%\00\x01\n\n\n\x03\x04\x04\x01\x12\x03\
    %\x08\x1f\n\x0c\n\x04\x04\x04\x03\0\x12\x04&\x02*\x03\n\x0c\n\x05\x04\
    \x04\x03\0\x01\x12\x03&\n\x13\n\r\n\x06\x04\x04\x03\0\x02\0\x12\x03'\x04\
    #\n\x0e\n\x07\x04\x04\x03\0\x02\0\x05\x12\x03'\x04\t\n\x0e\n\x07\x04\x04\
    \x03\0\x02\0\x01\x12\x03'\n\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\0\x03\x12\
    \x03'!\"\n\r\n\x06\x04\x04\x03\0\x02\x01\x12\x03(\x04\x16\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x01\x05\x12\x03(\x04\t\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x01\x01\x12\x03(\n\x11\n\x0e\n\x07\x04\x04\x03\0\x02\x01\x03\x12\x03(\
    \x14\x15\n\r\n\x06\x04\x04\x03\0\x02\x02\x12\x03)\x04\x15\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x02\x05\x12\x03)\x04\t\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x02\x01\x12\x03)\n\x10\n\x0e\n\x07\x04\x04\x03\0\x02\x02\x03\x12\x03)\
    \x13\x14\n\x0b\n\x04\x04\x04\x02\0\x12\x03,\x02#\n\x0c\n\x05\x04\x04\x02\
    \0\x05\x12\x03,\x02\x07\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03,\x08\x1e\n\
    \x0c\n\x05\x04\x04\x02\0\x03\x12\x03,!\"\n\x0b\n\x04\x04\x04\x02\x01\x12\
    \x03-\x02#\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03-\x02\n\n\x0c\n\x05\
    \x04\x04\x02\x01\x06\x12\x03-\x0b\x14\n\x0c\n\x05\x04\x04\x02\x01\x01\
    \x12\x03-\x15\x1e\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03-!\"\n\x0b\n\
    \x04\x04\x04\x02\x02\x12\x03.\x02\x12\n\x0c\n\x05\x04\x04\x02\x02\x05\
    \x12\x03.\x02\x08\n\x0c\n\x05\x04\x04\x02\x02\x01\x12\x03.\t\r\n\x0c\n\
    \x05\x04\x04\x02\x02\x03\x12\x03.\x10\x11\n\x0b\n\x04\x04\x04\x02\x03\
    \x12\x03/\x02\x14\n\x0c\n\x05\x04\x04\x02\x03\x05\x12\x03/\x02\x08\n\x0c\
    \n\x05\x04\x04\x02\x03\x01\x12\x03/\t\x0f\n\x0c\n\x05\x04\x04\x02\x03\
    \x03\x12\x03/\x12\x13\n\n\n\x02\x04\x05\x12\x044\0>\x01\n\n\n\x03\x04\
    \x05\x01\x12\x034\x08\x19\n\x0c\n\x04\x04\x05\x03\0\x12\x045\x028\x03\n\
    \x0c\n\x05\x04\x05\x03\0\x01\x12\x035\n\x19\n\r\n\x06\x04\x05\x03\0\x02\
    \0\x12\x036\x04\x13\n\x0e\n\x07\x04\x05\x03\0\x02\0\x05\x12\x036\x04\t\n\
    \x0e\n\x07\x04\x05\x03\0\x02\0\x01\x12\x036\n\x0e\n\x0e\n\x07\x04\x05\
    \x03\0\x02\0\x03\x12\x036\x11\x12\n\r\n\x06\x04\x05\x03\0\x02\x01\x12\
    \x037\x04\x15\n\x0e\n\x07\x04\x05\x03\0\x02\x01\x05\x12\x037\x04\t\n\x0e\
    \n\x07\x04\x05\x03\0\x02\x01\x01\x12\x037\n\x10\n\x0e\n\x07\x04\x05\x03\
    \0\x02\x01\x03\x12\x037\x13\x14\n\x0b\n\x04\x04\x05\x02\0\x12\x03:\x02'\
    \n\x0c\n\x05\x04\x05\x02\0\x06\x12\x03:\x02\x11\n\x0c\n\x05\x04\x05\x02\
    \0\x01\x12\x03:\x12\"\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03:%&\n\x0b\n\
    \x04\x04\x05\x02\x01\x12\x03;\x02\x16\n\x0c\n\x05\x04\x05\x02\x01\x05\
    \x12\x03;\x02\x07\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03;\x08\x11\n\x0c\
    \n\x05\x04\x05\x02\x01\x03\x12\x03;\x14\x15\n<\n\x04\x04\x05\x02\x02\x12\
    \x03<\x02A\"/\x20\x20BlockIdentifier\x20parent_block_identifier\x20=\x20\
    4;\n\n\x0c\n\x05\x04\x05\x02\x02\x04\x12\x03<\x02\n\n\x0c\n\x05\x04\x05\
    \x02\x02\x06\x12\x03<\x0b\"\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03<#<\n\
    \x0c\n\x05\x04\x05\x02\x02\x03\x12\x03<?@\n\n\n\x02\x04\x06\x12\x04@\0C\
    \x01\n\n\n\x03\x04\x06\x01\x12\x03@\x08\x14\n\x0b\n\x04\x04\x06\x02\0\
    \x12\x03A\x02\x14\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03A\x02\x07\n\x0c\n\
    \x05\x04\x06\x02\0\x01\x12\x03A\x08\x0f\n\x0c\n\x05\x04\x06\x02\0\x03\
    \x12\x03A\x12\x13\n\x0b\n\x04\x04\x06\x02\x01\x12\x03B\x02\x19\n\x0c\n\
    \x05\x04\x06\x02\x01\x05\x12\x03B\x02\x07\n\x0c\n\x05\x04\x06\x02\x01\
    \x01\x12\x03B\x08\x13\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03B\x16\x18\n\
    \n\n\x02\x04\x07\x12\x04E\0G\x01\n\n\n\x03\x04\x07\x01\x12\x03E\x08\x19\
    \n\x0b\n\x04\x04\x07\x02\0\x12\x03F\x02\x14\n\x0c\n\x05\x04\x07\x02\0\
    \x05\x12\x03F\x02\x07\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03F\x08\x0f\n\
    \x0c\n\x05\x04\x07\x02\0\x03\x12\x03F\x12\x13\n\n\n\x02\x04\x08\x12\x04I\
    \0L\x01\n\n\n\x03\x04\x08\x01\x12\x03I\x08\x1d\n\x0b\n\x04\x04\x08\x02\0\
    \x12\x03J\x02+\n\x0c\n\x05\x04\x08\x02\0\x06\x12\x03J\x02\x13\n\x0c\n\
    \x05\x04\x08\x02\0\x01\x12\x03J\x14&\n\x0c\n\x05\x04\x08\x02\0\x03\x12\
    \x03J)*\n\x0b\n\x04\x04\x08\x02\x01\x12\x03K\x029\n\x0c\n\x05\x04\x08\
    \x02\x01\x06\x12\x03K\x02#\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03K$4\n\
    \x0c\n\x05\x04\x08\x02\x01\x03\x12\x03K78\n\n\n\x02\x04\t\x12\x04N\0Q\
    \x01\n\n\n\x03\x04\t\x01\x12\x03N\x08\x1e\n\x0b\n\x04\x04\t\x02\0\x12\
    \x03O\x02\x14\n\x0c\n\x05\x04\t\x02\0\x05\x12\x03O\x02\x07\n\x0c\n\x05\
    \x04\t\x02\0\x01\x12\x03O\x08\x0f\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03O\
    \x12\x13\n\x0b\n\x04\x04\t\x02\x01\x12\x03P\x029\n\x0c\n\x05\x04\t\x02\
    \x01\x06\x12\x03P\x02#\n\x0c\n\x05\x04\t\x02\x01\x01\x12\x03P$4\n\x0c\n\
    \x05\x04\t\x02\x01\x03\x12\x03P78\n\n\n\x02\x04\n\x12\x04S\0W\x01\n\n\n\
    \x03\x04\n\x01\x12\x03S\x08\x1f\n\x0b\n\x04\x04\n\x02\0\x12\x03T\x02\x1a\
    \n\x0c\n\x05\x04\n\x02\0\x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\n\x02\0\
    \x01\x12\x03T\x08\x15\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03T\x18\x19\n\x0b\
    \n\x04\x04\n\x02\x01\x12\x03U\x02\x1b\n\x0c\n\x05\x04\n\x02\x01\x05\x12\
    \x03U\x02\x07\n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03U\x08\x16\n\x0c\n\x05\
    \x04\n\x02\x01\x03\x12\x03U\x19\x1a\n\x0b\n\x04\x04\n\x02\x02\x12\x03V\
    \x02\x1c\n\x0c\n\x05\x04\n\x02\x02\x06\x12\x03V\x02\x0e\n\x0c\n\x05\x04\
    \n\x02\x02\x01\x12\x03V\x0f\x17\n\x0c\n\x05\x04\n\x02\x02\x03\x12\x03V\
    \x1a\x1b\n\n\n\x02\x04\x0b\x12\x04Y\0]\x01\n\n\n\x03\x04\x0b\x01\x12\x03\
    Y\x08!\n\x0b\n\x04\x04\x0b\x02\0\x12\x03Z\x02\x1a\n\x0c\n\x05\x04\x0b\
    \x02\0\x05\x12\x03Z\x02\x07\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03Z\x08\
    \x15\n\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03Z\x18\x19\n\x0b\n\x04\x04\x0b\
    \x02\x01\x12\x03[\x02\x1d\n\x0c\n\x05\x04\x0b\x02\x01\x05\x12\x03[\x02\
    \x07\n\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x03[\x08\x18\n\x0c\n\x05\x04\
    \x0b\x02\x01\x03\x12\x03[\x1b\x1c\n\x0b\n\x04\x04\x0b\x02\x02\x12\x03\\\
    \x02\x1c\n\x0c\n\x05\x04\x0b\x02\x02\x06\x12\x03\\\x02\x0e\n\x0c\n\x05\
    \x04\x0b\x02\x02\x01\x12\x03\\\x0f\x17\n\x0c\n\x05\x04\x0b\x02\x02\x03\
    \x12\x03\\\x1a\x1b\n\n\n\x02\x04\x0c\x12\x04_\0a\x01\n\n\n\x03\x04\x0c\
    \x01\x12\x03_\x08&\n\x0b\n\x04\x04\x0c\x02\0\x12\x03`\x02\x1a\n\x0c\n\
    \x05\x04\x0c\x02\0\x05\x12\x03`\x02\x07\n\x0c\n\x05\x04\x0c\x02\0\x01\
    \x12\x03`\x08\x15\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03`\x18\x19\n\n\n\
    \x02\x04\r\x12\x04c\0j\x01\n\n\n\x03\x04\r\x01\x12\x03c\x08\x20\n\x0b\n\
    \x04\x04\r\x02\0\x12\x03d\x02\x1a\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03d\
    \x02\x07\n\x0c\n\x05\x04\r\x02\0\x01\x12\x03d\x08\x15\n\x0c\n\x05\x04\r\
    \x02\0\x03\x12\x03d\x18\x19\n\x0b\n\x04\x04\r\x02\x01\x12\x03e\x02\x1c\n\
    \x0c\n\x05\x04\r\x02\x01\x06\x12\x03e\x02\x0e\n\x0c\n\x05\x04\r\x02\x01\
    \x01\x12\x03e\x0f\x17\n\x0c\n\x05\x04\r\x02\x01\x03\x12\x03e\x1a\x1b\n\
    \x0b\n\x04\x04\r\x02\x02\x12\x03f\x02\x14\n\x0c\n\x05\x04\r\x02\x02\x05\
    \x12\x03f\x02\x07\n\x0c\n\x05\x04\r\x02\x02\x01\x12\x03f\x08\x0f\n\x0c\n\
    \x05\x04\r\x02\x02\x03\x12\x03f\x12\x13\n\x0b\n\x04\x04\r\x02\x03\x12\
    \x03g\x02\x1d\n\x0c\n\x05\x04\r\x02\x03\x05\x12\x03g\x02\x07\n\x0c\n\x05\
    \x04\r\x02\x03\x01\x12\x03g\x08\x18\n\x0c\n\x05\x04\r\x02\x03\x03\x12\
    \x03g\x1b\x1c\n\x0b\n\x04\x04\r\x02\x04\x12\x03h\x02\x11\n\x0c\n\x05\x04\
    \r\x02\x04\x05\x12\x03h\x02\x06\n\x0c\n\x05\x04\r\x02\x04\x01\x12\x03h\
    \x08\x0c\n\x0c\n\x05\x04\r\x02\x04\x03\x12\x03h\x0f\x10\n\x0b\n\x04\x04\
    \r\x02\x05\x12\x03i\x02\x18\n\x0c\n\x05\x04\r\x02\x05\x05\x12\x03i\x02\
    \x07\n\x0c\n\x05\x04\r\x02\x05\x01\x12\x03i\x08\x13\n\x0c\n\x05\x04\r\
    \x02\x05\x03\x12\x03i\x16\x17\n\n\n\x02\x04\x0e\x12\x04l\0q\x01\n\n\n\
    \x03\x04\x0e\x01\x12\x03l\x08\"\n\x0b\n\x04\x04\x0e\x02\0\x12\x03m\x02\
    \x1a\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03m\x02\x07\n\x0c\n\x05\x04\x0e\
    \x02\0\x01\x12\x03m\x08\x15\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\x03m\x18\
    \x19\n\x0b\n\x04\x04\x0e\x02\x01\x12\x03n\x02\x1c\n\x0c\n\x05\x04\x0e\
    \x02\x01\x06\x12\x03n\x02\x0e\n\x0c\n\x05\x04\x0e\x02\x01\x01\x12\x03n\
    \x0f\x17\n\x0c\n\x05\x04\x0e\x02\x01\x03\x12\x03n\x1a\x1b\n\x0b\n\x04\
    \x04\x0e\x02\x02\x12\x03o\x02\x14\n\x0c\n\x05\x04\x0e\x02\x02\x05\x12\
    \x03o\x02\x07\n\x0c\n\x05\x04\x0e\x02\x02\x01\x12\x03o\x08\x0f\n\x0c\n\
    \x05\x04\x0e\x02\x02\x03\x12\x03o\x12\x13\n\x0b\n\x04\x04\x0e\x02\x03\
    \x12\x03p\x02\x1d\n\x0c\n\x05\x04\x0e\x02\x03\x05\x12\x03p\x02\x07\n\x0c\
    \n\x05\x04\x0e\x02\x03\x01\x12\x03p\x08\x18\n\x0c\n\x05\x04\x0e\x02\x03\
    \x03\x12\x03p\x1b\x1c\n\n\n\x02\x04\x0f\x12\x04s\0u\x01\n\n\n\x03\x04\
    \x0f\x01\x12\x03s\x08#\n\x0b\n\x04\x04\x0f\x02\0\x12\x03t\x02\x1a\n\x0c\
    \n\x05\x04\x0f\x02\0\x05\x12\x03t\x02\x07\n\x0c\n\x05\x04\x0f\x02\0\x01\
    \x12\x03t\x08\x15\n\x0c\n\x05\x04\x0f\x02\0\x03\x12\x03t\x18\x19b\x06pro\
    to3\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(1);
            deps.push(super::common::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(18);
            messages.push(FreezeBalanceContract::generated_message_descriptor_data());
            messages.push(UnfreezeBalanceContract::generated_message_descriptor_data());
            messages.push(WithdrawBalanceContract::generated_message_descriptor_data());
            messages.push(TransferContract::generated_message_descriptor_data());
            messages.push(TransactionBalanceTrace::generated_message_descriptor_data());
            messages.push(BlockBalanceTrace::generated_message_descriptor_data());
            messages.push(AccountTrace::generated_message_descriptor_data());
            messages.push(AccountIdentifier::generated_message_descriptor_data());
            messages.push(AccountBalanceRequest::generated_message_descriptor_data());
            messages.push(AccountBalanceResponse::generated_message_descriptor_data());
            messages.push(FreezeBalanceV2Contract::generated_message_descriptor_data());
            messages.push(UnfreezeBalanceV2Contract::generated_message_descriptor_data());
            messages.push(WithdrawExpireUnfreezeContract::generated_message_descriptor_data());
            messages.push(DelegateResourceContract::generated_message_descriptor_data());
            messages.push(UnDelegateResourceContract::generated_message_descriptor_data());
            messages.push(CancelAllUnfreezeV2Contract::generated_message_descriptor_data());
            messages.push(transaction_balance_trace::Operation::generated_message_descriptor_data());
            messages.push(block_balance_trace::BlockIdentifier::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}