anychain-tron 0.2.6

// 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/smart_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.SmartContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SmartContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.SmartContract.origin_address)
    pub origin_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContract.contract_address)
    pub contract_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContract.abi)
    pub abi: ::protobuf::MessageField<smart_contract::ABI>,
    // @@protoc_insertion_point(field:protocol.SmartContract.bytecode)
    pub bytecode: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContract.call_value)
    pub call_value: i64,
    // @@protoc_insertion_point(field:protocol.SmartContract.consume_user_resource_percent)
    pub consume_user_resource_percent: i64,
    // @@protoc_insertion_point(field:protocol.SmartContract.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:protocol.SmartContract.origin_energy_limit)
    pub origin_energy_limit: i64,
    // @@protoc_insertion_point(field:protocol.SmartContract.code_hash)
    pub code_hash: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContract.trx_hash)
    pub trx_hash: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContract.version)
    pub version: i32,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.SmartContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(11);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "origin_address",
            |m: &SmartContract| { &m.origin_address },
            |m: &mut SmartContract| { &mut m.origin_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "contract_address",
            |m: &SmartContract| { &m.contract_address },
            |m: &mut SmartContract| { &mut m.contract_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, smart_contract::ABI>(
            "abi",
            |m: &SmartContract| { &m.abi },
            |m: &mut SmartContract| { &mut m.abi },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "bytecode",
            |m: &SmartContract| { &m.bytecode },
            |m: &mut SmartContract| { &mut m.bytecode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "call_value",
            |m: &SmartContract| { &m.call_value },
            |m: &mut SmartContract| { &mut m.call_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "consume_user_resource_percent",
            |m: &SmartContract| { &m.consume_user_resource_percent },
            |m: &mut SmartContract| { &mut m.consume_user_resource_percent },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &SmartContract| { &m.name },
            |m: &mut SmartContract| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "origin_energy_limit",
            |m: &SmartContract| { &m.origin_energy_limit },
            |m: &mut SmartContract| { &mut m.origin_energy_limit },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "code_hash",
            |m: &SmartContract| { &m.code_hash },
            |m: &mut SmartContract| { &mut m.code_hash },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "trx_hash",
            |m: &SmartContract| { &m.trx_hash },
            |m: &mut SmartContract| { &mut m.trx_hash },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "version",
            |m: &SmartContract| { &m.version },
            |m: &mut SmartContract| { &mut m.version },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SmartContract>(
            "SmartContract",
            fields,
            oneofs,
        )
    }
}

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

    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.origin_address = is.read_bytes()?;
                },
                18 => {
                    self.contract_address = is.read_bytes()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.abi)?;
                },
                34 => {
                    self.bytecode = is.read_bytes()?;
                },
                40 => {
                    self.call_value = is.read_int64()?;
                },
                48 => {
                    self.consume_user_resource_percent = is.read_int64()?;
                },
                58 => {
                    self.name = is.read_string()?;
                },
                64 => {
                    self.origin_energy_limit = is.read_int64()?;
                },
                74 => {
                    self.code_hash = is.read_bytes()?;
                },
                82 => {
                    self.trx_hash = is.read_bytes()?;
                },
                88 => {
                    self.version = is.read_int32()?;
                },
                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.origin_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.origin_address);
        }
        if !self.contract_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
        }
        if let Some(v) = self.abi.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.bytecode.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.bytecode);
        }
        if self.call_value != 0 {
            my_size += ::protobuf::rt::int64_size(5, self.call_value);
        }
        if self.consume_user_resource_percent != 0 {
            my_size += ::protobuf::rt::int64_size(6, self.consume_user_resource_percent);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.name);
        }
        if self.origin_energy_limit != 0 {
            my_size += ::protobuf::rt::int64_size(8, self.origin_energy_limit);
        }
        if !self.code_hash.is_empty() {
            my_size += ::protobuf::rt::bytes_size(9, &self.code_hash);
        }
        if !self.trx_hash.is_empty() {
            my_size += ::protobuf::rt::bytes_size(10, &self.trx_hash);
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::int32_size(11, self.version);
        }
        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.origin_address.is_empty() {
            os.write_bytes(1, &self.origin_address)?;
        }
        if !self.contract_address.is_empty() {
            os.write_bytes(2, &self.contract_address)?;
        }
        if let Some(v) = self.abi.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if !self.bytecode.is_empty() {
            os.write_bytes(4, &self.bytecode)?;
        }
        if self.call_value != 0 {
            os.write_int64(5, self.call_value)?;
        }
        if self.consume_user_resource_percent != 0 {
            os.write_int64(6, self.consume_user_resource_percent)?;
        }
        if !self.name.is_empty() {
            os.write_string(7, &self.name)?;
        }
        if self.origin_energy_limit != 0 {
            os.write_int64(8, self.origin_energy_limit)?;
        }
        if !self.code_hash.is_empty() {
            os.write_bytes(9, &self.code_hash)?;
        }
        if !self.trx_hash.is_empty() {
            os.write_bytes(10, &self.trx_hash)?;
        }
        if self.version != 0 {
            os.write_int32(11, self.version)?;
        }
        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() -> SmartContract {
        SmartContract::new()
    }

    fn clear(&mut self) {
        self.origin_address.clear();
        self.contract_address.clear();
        self.abi.clear();
        self.bytecode.clear();
        self.call_value = 0;
        self.consume_user_resource_percent = 0;
        self.name.clear();
        self.origin_energy_limit = 0;
        self.code_hash.clear();
        self.trx_hash.clear();
        self.version = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SmartContract {
        static instance: SmartContract = SmartContract {
            origin_address: ::std::vec::Vec::new(),
            contract_address: ::std::vec::Vec::new(),
            abi: ::protobuf::MessageField::none(),
            bytecode: ::std::vec::Vec::new(),
            call_value: 0,
            consume_user_resource_percent: 0,
            name: ::std::string::String::new(),
            origin_energy_limit: 0,
            code_hash: ::std::vec::Vec::new(),
            trx_hash: ::std::vec::Vec::new(),
            version: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for SmartContract {
    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("SmartContract").unwrap()).clone()
    }
}

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

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

/// Nested message and enums of message `SmartContract`
pub mod smart_contract {
    // @@protoc_insertion_point(message:protocol.SmartContract.ABI)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ABI {
        // message fields
        // @@protoc_insertion_point(field:protocol.SmartContract.ABI.entrys)
        pub entrys: ::std::vec::Vec<abi::Entry>,
        // special fields
        // @@protoc_insertion_point(special_field:protocol.SmartContract.ABI.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) 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_vec_simpler_accessor::<_, _>(
                "entrys",
                |m: &ABI| { &m.entrys },
                |m: &mut ABI| { &mut m.entrys },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ABI>(
                "SmartContract.ABI",
                fields,
                oneofs,
            )
        }
    }

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

        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.entrys.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;
            for value in &self.entrys {
                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<()> {
            for v in &self.entrys {
                ::protobuf::rt::write_message_field_with_cached_size(1, 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() -> ABI {
            ABI::new()
        }

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

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

    impl ::protobuf::MessageFull for ABI {
        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("SmartContract.ABI").unwrap()).clone()
        }
    }

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

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

    /// Nested message and enums of message `ABI`
    pub mod abi {
        // @@protoc_insertion_point(message:protocol.SmartContract.ABI.Entry)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Entry {
            // message fields
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.anonymous)
            pub anonymous: bool,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.constant)
            pub constant: bool,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.name)
            pub name: ::std::string::String,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.inputs)
            pub inputs: ::std::vec::Vec<entry::Param>,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.outputs)
            pub outputs: ::std::vec::Vec<entry::Param>,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.type)
            pub type_: ::protobuf::EnumOrUnknown<entry::EntryType>,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.payable)
            pub payable: bool,
            // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.stateMutability)
            pub stateMutability: ::protobuf::EnumOrUnknown<entry::StateMutabilityType>,
            // special fields
            // @@protoc_insertion_point(special_field:protocol.SmartContract.ABI.Entry.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(8);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "anonymous",
                    |m: &Entry| { &m.anonymous },
                    |m: &mut Entry| { &mut m.anonymous },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "constant",
                    |m: &Entry| { &m.constant },
                    |m: &mut Entry| { &mut m.constant },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "name",
                    |m: &Entry| { &m.name },
                    |m: &mut Entry| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                    "inputs",
                    |m: &Entry| { &m.inputs },
                    |m: &mut Entry| { &mut m.inputs },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                    "outputs",
                    |m: &Entry| { &m.outputs },
                    |m: &mut Entry| { &mut m.outputs },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "type",
                    |m: &Entry| { &m.type_ },
                    |m: &mut Entry| { &mut m.type_ },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "payable",
                    |m: &Entry| { &m.payable },
                    |m: &mut Entry| { &mut m.payable },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "stateMutability",
                    |m: &Entry| { &m.stateMutability },
                    |m: &mut Entry| { &mut m.stateMutability },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Entry>(
                    "SmartContract.ABI.Entry",
                    fields,
                    oneofs,
                )
            }
        }

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

            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.anonymous = is.read_bool()?;
                        },
                        16 => {
                            self.constant = is.read_bool()?;
                        },
                        26 => {
                            self.name = is.read_string()?;
                        },
                        34 => {
                            self.inputs.push(is.read_message()?);
                        },
                        42 => {
                            self.outputs.push(is.read_message()?);
                        },
                        48 => {
                            self.type_ = is.read_enum_or_unknown()?;
                        },
                        56 => {
                            self.payable = is.read_bool()?;
                        },
                        64 => {
                            self.stateMutability = 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.anonymous != false {
                    my_size += 1 + 1;
                }
                if self.constant != false {
                    my_size += 1 + 1;
                }
                if !self.name.is_empty() {
                    my_size += ::protobuf::rt::string_size(3, &self.name);
                }
                for value in &self.inputs {
                    let len = value.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                };
                for value in &self.outputs {
                    let len = value.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                };
                if self.type_ != ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType) {
                    my_size += ::protobuf::rt::int32_size(6, self.type_.value());
                }
                if self.payable != false {
                    my_size += 1 + 1;
                }
                if self.stateMutability != ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType) {
                    my_size += ::protobuf::rt::int32_size(8, self.stateMutability.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.anonymous != false {
                    os.write_bool(1, self.anonymous)?;
                }
                if self.constant != false {
                    os.write_bool(2, self.constant)?;
                }
                if !self.name.is_empty() {
                    os.write_string(3, &self.name)?;
                }
                for v in &self.inputs {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                };
                for v in &self.outputs {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                };
                if self.type_ != ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType) {
                    os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.type_))?;
                }
                if self.payable != false {
                    os.write_bool(7, self.payable)?;
                }
                if self.stateMutability != ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType) {
                    os.write_enum(8, ::protobuf::EnumOrUnknown::value(&self.stateMutability))?;
                }
                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() -> Entry {
                Entry::new()
            }

            fn clear(&mut self) {
                self.anonymous = false;
                self.constant = false;
                self.name.clear();
                self.inputs.clear();
                self.outputs.clear();
                self.type_ = ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType);
                self.payable = false;
                self.stateMutability = ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType);
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Entry {
                static instance: Entry = Entry {
                    anonymous: false,
                    constant: false,
                    name: ::std::string::String::new(),
                    inputs: ::std::vec::Vec::new(),
                    outputs: ::std::vec::Vec::new(),
                    type_: ::protobuf::EnumOrUnknown::from_i32(0),
                    payable: false,
                    stateMutability: ::protobuf::EnumOrUnknown::from_i32(0),
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

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

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

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

        /// Nested message and enums of message `Entry`
        pub mod entry {
            // @@protoc_insertion_point(message:protocol.SmartContract.ABI.Entry.Param)
            #[derive(PartialEq,Clone,Default,Debug)]
            pub struct Param {
                // message fields
                // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.Param.indexed)
                pub indexed: bool,
                // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.Param.name)
                pub name: ::std::string::String,
                // @@protoc_insertion_point(field:protocol.SmartContract.ABI.Entry.Param.type)
                pub type_: ::std::string::String,
                // special fields
                // @@protoc_insertion_point(special_field:protocol.SmartContract.ABI.Entry.Param.special_fields)
                pub special_fields: ::protobuf::SpecialFields,
            }

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

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

                pub(in super::super::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::<_, _>(
                        "indexed",
                        |m: &Param| { &m.indexed },
                        |m: &mut Param| { &mut m.indexed },
                    ));
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "name",
                        |m: &Param| { &m.name },
                        |m: &mut Param| { &mut m.name },
                    ));
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "type",
                        |m: &Param| { &m.type_ },
                        |m: &mut Param| { &mut m.type_ },
                    ));
                    ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Param>(
                        "SmartContract.ABI.Entry.Param",
                        fields,
                        oneofs,
                    )
                }
            }

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

                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.indexed = is.read_bool()?;
                            },
                            18 => {
                                self.name = is.read_string()?;
                            },
                            26 => {
                                self.type_ = 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.indexed != false {
                        my_size += 1 + 1;
                    }
                    if !self.name.is_empty() {
                        my_size += ::protobuf::rt::string_size(2, &self.name);
                    }
                    if !self.type_.is_empty() {
                        my_size += ::protobuf::rt::string_size(3, &self.type_);
                    }
                    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.indexed != false {
                        os.write_bool(1, self.indexed)?;
                    }
                    if !self.name.is_empty() {
                        os.write_string(2, &self.name)?;
                    }
                    if !self.type_.is_empty() {
                        os.write_string(3, &self.type_)?;
                    }
                    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() -> Param {
                    Param::new()
                }

                fn clear(&mut self) {
                    self.indexed = false;
                    self.name.clear();
                    self.type_.clear();
                    self.special_fields.clear();
                }

                fn default_instance() -> &'static Param {
                    static instance: Param = Param {
                        indexed: false,
                        name: ::std::string::String::new(),
                        type_: ::std::string::String::new(),
                        special_fields: ::protobuf::SpecialFields::new(),
                    };
                    &instance
                }
            }

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

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

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

            #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
            // @@protoc_insertion_point(enum:protocol.SmartContract.ABI.Entry.EntryType)
            pub enum EntryType {
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.UnknownEntryType)
                UnknownEntryType = 0,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Constructor)
                Constructor = 1,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Function)
                Function = 2,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Event)
                Event = 3,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Fallback)
                Fallback = 4,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Receive)
                Receive = 5,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.EntryType.Error)
                Error = 6,
            }

            impl ::protobuf::Enum for EntryType {
                const NAME: &'static str = "EntryType";

                fn value(&self) -> i32 {
                    *self as i32
                }

                fn from_i32(value: i32) -> ::std::option::Option<EntryType> {
                    match value {
                        0 => ::std::option::Option::Some(EntryType::UnknownEntryType),
                        1 => ::std::option::Option::Some(EntryType::Constructor),
                        2 => ::std::option::Option::Some(EntryType::Function),
                        3 => ::std::option::Option::Some(EntryType::Event),
                        4 => ::std::option::Option::Some(EntryType::Fallback),
                        5 => ::std::option::Option::Some(EntryType::Receive),
                        6 => ::std::option::Option::Some(EntryType::Error),
                        _ => ::std::option::Option::None
                    }
                }

                fn from_str(str: &str) -> ::std::option::Option<EntryType> {
                    match str {
                        "UnknownEntryType" => ::std::option::Option::Some(EntryType::UnknownEntryType),
                        "Constructor" => ::std::option::Option::Some(EntryType::Constructor),
                        "Function" => ::std::option::Option::Some(EntryType::Function),
                        "Event" => ::std::option::Option::Some(EntryType::Event),
                        "Fallback" => ::std::option::Option::Some(EntryType::Fallback),
                        "Receive" => ::std::option::Option::Some(EntryType::Receive),
                        "Error" => ::std::option::Option::Some(EntryType::Error),
                        _ => ::std::option::Option::None
                    }
                }

                const VALUES: &'static [EntryType] = &[
                    EntryType::UnknownEntryType,
                    EntryType::Constructor,
                    EntryType::Function,
                    EntryType::Event,
                    EntryType::Fallback,
                    EntryType::Receive,
                    EntryType::Error,
                ];
            }

            impl ::protobuf::EnumFull for EntryType {
                fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
                    static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
                    descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("SmartContract.ABI.Entry.EntryType").unwrap()).clone()
                }

                fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
                    let index = *self as usize;
                    Self::enum_descriptor().value_by_index(index)
                }
            }

            impl ::std::default::Default for EntryType {
                fn default() -> Self {
                    EntryType::UnknownEntryType
                }
            }

            impl EntryType {
                pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
                    ::protobuf::reflect::GeneratedEnumDescriptorData::new::<EntryType>("SmartContract.ABI.Entry.EntryType")
                }
            }

            #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
            // @@protoc_insertion_point(enum:protocol.SmartContract.ABI.Entry.StateMutabilityType)
            pub enum StateMutabilityType {
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.StateMutabilityType.UnknownMutabilityType)
                UnknownMutabilityType = 0,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.StateMutabilityType.Pure)
                Pure = 1,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.StateMutabilityType.View)
                View = 2,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.StateMutabilityType.Nonpayable)
                Nonpayable = 3,
                // @@protoc_insertion_point(enum_value:protocol.SmartContract.ABI.Entry.StateMutabilityType.Payable)
                Payable = 4,
            }

            impl ::protobuf::Enum for StateMutabilityType {
                const NAME: &'static str = "StateMutabilityType";

                fn value(&self) -> i32 {
                    *self as i32
                }

                fn from_i32(value: i32) -> ::std::option::Option<StateMutabilityType> {
                    match value {
                        0 => ::std::option::Option::Some(StateMutabilityType::UnknownMutabilityType),
                        1 => ::std::option::Option::Some(StateMutabilityType::Pure),
                        2 => ::std::option::Option::Some(StateMutabilityType::View),
                        3 => ::std::option::Option::Some(StateMutabilityType::Nonpayable),
                        4 => ::std::option::Option::Some(StateMutabilityType::Payable),
                        _ => ::std::option::Option::None
                    }
                }

                fn from_str(str: &str) -> ::std::option::Option<StateMutabilityType> {
                    match str {
                        "UnknownMutabilityType" => ::std::option::Option::Some(StateMutabilityType::UnknownMutabilityType),
                        "Pure" => ::std::option::Option::Some(StateMutabilityType::Pure),
                        "View" => ::std::option::Option::Some(StateMutabilityType::View),
                        "Nonpayable" => ::std::option::Option::Some(StateMutabilityType::Nonpayable),
                        "Payable" => ::std::option::Option::Some(StateMutabilityType::Payable),
                        _ => ::std::option::Option::None
                    }
                }

                const VALUES: &'static [StateMutabilityType] = &[
                    StateMutabilityType::UnknownMutabilityType,
                    StateMutabilityType::Pure,
                    StateMutabilityType::View,
                    StateMutabilityType::Nonpayable,
                    StateMutabilityType::Payable,
                ];
            }

            impl ::protobuf::EnumFull for StateMutabilityType {
                fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
                    static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
                    descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("SmartContract.ABI.Entry.StateMutabilityType").unwrap()).clone()
                }

                fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
                    let index = *self as usize;
                    Self::enum_descriptor().value_by_index(index)
                }
            }

            impl ::std::default::Default for StateMutabilityType {
                fn default() -> Self {
                    StateMutabilityType::UnknownMutabilityType
                }
            }

            impl StateMutabilityType {
                pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
                    ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateMutabilityType>("SmartContract.ABI.Entry.StateMutabilityType")
                }
            }
        }
    }
}

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

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

impl ContractState {
    pub fn new() -> ContractState {
        ::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::<_, _>(
            "energy_usage",
            |m: &ContractState| { &m.energy_usage },
            |m: &mut ContractState| { &mut m.energy_usage },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "energy_factor",
            |m: &ContractState| { &m.energy_factor },
            |m: &mut ContractState| { &mut m.energy_factor },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "update_cycle",
            |m: &ContractState| { &m.update_cycle },
            |m: &mut ContractState| { &mut m.update_cycle },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ContractState>(
            "ContractState",
            fields,
            oneofs,
        )
    }
}

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

    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.energy_usage = is.read_int64()?;
                },
                16 => {
                    self.energy_factor = is.read_int64()?;
                },
                24 => {
                    self.update_cycle = 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.energy_usage != 0 {
            my_size += ::protobuf::rt::int64_size(1, self.energy_usage);
        }
        if self.energy_factor != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.energy_factor);
        }
        if self.update_cycle != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.update_cycle);
        }
        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.energy_usage != 0 {
            os.write_int64(1, self.energy_usage)?;
        }
        if self.energy_factor != 0 {
            os.write_int64(2, self.energy_factor)?;
        }
        if self.update_cycle != 0 {
            os.write_int64(3, self.update_cycle)?;
        }
        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() -> ContractState {
        ContractState::new()
    }

    fn clear(&mut self) {
        self.energy_usage = 0;
        self.energy_factor = 0;
        self.update_cycle = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ContractState {
        static instance: ContractState = ContractState {
            energy_usage: 0,
            energy_factor: 0,
            update_cycle: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for ContractState {
    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("ContractState").unwrap()).clone()
    }
}

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

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

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

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

impl CreateSmartContract {
    pub fn new() -> CreateSmartContract {
        ::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: &CreateSmartContract| { &m.owner_address },
            |m: &mut CreateSmartContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SmartContract>(
            "new_contract",
            |m: &CreateSmartContract| { &m.new_contract },
            |m: &mut CreateSmartContract| { &mut m.new_contract },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "call_token_value",
            |m: &CreateSmartContract| { &m.call_token_value },
            |m: &mut CreateSmartContract| { &mut m.call_token_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "token_id",
            |m: &CreateSmartContract| { &m.token_id },
            |m: &mut CreateSmartContract| { &mut m.token_id },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CreateSmartContract>(
            "CreateSmartContract",
            fields,
            oneofs,
        )
    }
}

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.new_contract)?;
                },
                24 => {
                    self.call_token_value = is.read_int64()?;
                },
                32 => {
                    self.token_id = 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 let Some(v) = self.new_contract.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.call_token_value != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.call_token_value);
        }
        if self.token_id != 0 {
            my_size += ::protobuf::rt::int64_size(4, self.token_id);
        }
        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 let Some(v) = self.new_contract.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if self.call_token_value != 0 {
            os.write_int64(3, self.call_token_value)?;
        }
        if self.token_id != 0 {
            os.write_int64(4, self.token_id)?;
        }
        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() -> CreateSmartContract {
        CreateSmartContract::new()
    }

    fn clear(&mut self) {
        self.owner_address.clear();
        self.new_contract.clear();
        self.call_token_value = 0;
        self.token_id = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CreateSmartContract {
        static instance: CreateSmartContract = CreateSmartContract {
            owner_address: ::std::vec::Vec::new(),
            new_contract: ::protobuf::MessageField::none(),
            call_token_value: 0,
            token_id: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for CreateSmartContract {
    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("CreateSmartContract").unwrap()).clone()
    }
}

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

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

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

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

impl TriggerSmartContract {
    pub fn new() -> TriggerSmartContract {
        ::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: &TriggerSmartContract| { &m.owner_address },
            |m: &mut TriggerSmartContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "contract_address",
            |m: &TriggerSmartContract| { &m.contract_address },
            |m: &mut TriggerSmartContract| { &mut m.contract_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "call_value",
            |m: &TriggerSmartContract| { &m.call_value },
            |m: &mut TriggerSmartContract| { &mut m.call_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "data",
            |m: &TriggerSmartContract| { &m.data },
            |m: &mut TriggerSmartContract| { &mut m.data },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "call_token_value",
            |m: &TriggerSmartContract| { &m.call_token_value },
            |m: &mut TriggerSmartContract| { &mut m.call_token_value },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "token_id",
            |m: &TriggerSmartContract| { &m.token_id },
            |m: &mut TriggerSmartContract| { &mut m.token_id },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TriggerSmartContract>(
            "TriggerSmartContract",
            fields,
            oneofs,
        )
    }
}

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

    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.contract_address = is.read_bytes()?;
                },
                24 => {
                    self.call_value = is.read_int64()?;
                },
                34 => {
                    self.data = is.read_bytes()?;
                },
                40 => {
                    self.call_token_value = is.read_int64()?;
                },
                48 => {
                    self.token_id = 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.contract_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
        }
        if self.call_value != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.call_value);
        }
        if !self.data.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.data);
        }
        if self.call_token_value != 0 {
            my_size += ::protobuf::rt::int64_size(5, self.call_token_value);
        }
        if self.token_id != 0 {
            my_size += ::protobuf::rt::int64_size(6, self.token_id);
        }
        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.contract_address.is_empty() {
            os.write_bytes(2, &self.contract_address)?;
        }
        if self.call_value != 0 {
            os.write_int64(3, self.call_value)?;
        }
        if !self.data.is_empty() {
            os.write_bytes(4, &self.data)?;
        }
        if self.call_token_value != 0 {
            os.write_int64(5, self.call_token_value)?;
        }
        if self.token_id != 0 {
            os.write_int64(6, self.token_id)?;
        }
        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() -> TriggerSmartContract {
        TriggerSmartContract::new()
    }

    fn clear(&mut self) {
        self.owner_address.clear();
        self.contract_address.clear();
        self.call_value = 0;
        self.data.clear();
        self.call_token_value = 0;
        self.token_id = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TriggerSmartContract {
        static instance: TriggerSmartContract = TriggerSmartContract {
            owner_address: ::std::vec::Vec::new(),
            contract_address: ::std::vec::Vec::new(),
            call_value: 0,
            data: ::std::vec::Vec::new(),
            call_token_value: 0,
            token_id: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TriggerSmartContract {
    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("TriggerSmartContract").unwrap()).clone()
    }
}

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

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

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

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

impl ClearABIContract {
    pub fn new() -> ClearABIContract {
        ::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::<_, _>(
            "owner_address",
            |m: &ClearABIContract| { &m.owner_address },
            |m: &mut ClearABIContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "contract_address",
            |m: &ClearABIContract| { &m.contract_address },
            |m: &mut ClearABIContract| { &mut m.contract_address },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClearABIContract>(
            "ClearABIContract",
            fields,
            oneofs,
        )
    }
}

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

    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.contract_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.contract_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.contract_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.contract_address.is_empty() {
            os.write_bytes(2, &self.contract_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() -> ClearABIContract {
        ClearABIContract::new()
    }

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

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

impl ::protobuf::MessageFull for ClearABIContract {
    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("ClearABIContract").unwrap()).clone()
    }
}

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

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

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

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

impl UpdateSettingContract {
    pub fn new() -> UpdateSettingContract {
        ::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: &UpdateSettingContract| { &m.owner_address },
            |m: &mut UpdateSettingContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "contract_address",
            |m: &UpdateSettingContract| { &m.contract_address },
            |m: &mut UpdateSettingContract| { &mut m.contract_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "consume_user_resource_percent",
            |m: &UpdateSettingContract| { &m.consume_user_resource_percent },
            |m: &mut UpdateSettingContract| { &mut m.consume_user_resource_percent },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateSettingContract>(
            "UpdateSettingContract",
            fields,
            oneofs,
        )
    }
}

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

    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.contract_address = is.read_bytes()?;
                },
                24 => {
                    self.consume_user_resource_percent = 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.contract_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
        }
        if self.consume_user_resource_percent != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.consume_user_resource_percent);
        }
        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.contract_address.is_empty() {
            os.write_bytes(2, &self.contract_address)?;
        }
        if self.consume_user_resource_percent != 0 {
            os.write_int64(3, self.consume_user_resource_percent)?;
        }
        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() -> UpdateSettingContract {
        UpdateSettingContract::new()
    }

    fn clear(&mut self) {
        self.owner_address.clear();
        self.contract_address.clear();
        self.consume_user_resource_percent = 0;
        self.special_fields.clear();
    }

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

impl ::protobuf::MessageFull for UpdateSettingContract {
    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("UpdateSettingContract").unwrap()).clone()
    }
}

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

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

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

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

impl UpdateEnergyLimitContract {
    pub fn new() -> UpdateEnergyLimitContract {
        ::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: &UpdateEnergyLimitContract| { &m.owner_address },
            |m: &mut UpdateEnergyLimitContract| { &mut m.owner_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "contract_address",
            |m: &UpdateEnergyLimitContract| { &m.contract_address },
            |m: &mut UpdateEnergyLimitContract| { &mut m.contract_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "origin_energy_limit",
            |m: &UpdateEnergyLimitContract| { &m.origin_energy_limit },
            |m: &mut UpdateEnergyLimitContract| { &mut m.origin_energy_limit },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateEnergyLimitContract>(
            "UpdateEnergyLimitContract",
            fields,
            oneofs,
        )
    }
}

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

    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.contract_address = is.read_bytes()?;
                },
                24 => {
                    self.origin_energy_limit = 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.contract_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
        }
        if self.origin_energy_limit != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.origin_energy_limit);
        }
        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.contract_address.is_empty() {
            os.write_bytes(2, &self.contract_address)?;
        }
        if self.origin_energy_limit != 0 {
            os.write_int64(3, self.origin_energy_limit)?;
        }
        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() -> UpdateEnergyLimitContract {
        UpdateEnergyLimitContract::new()
    }

    fn clear(&mut self) {
        self.owner_address.clear();
        self.contract_address.clear();
        self.origin_energy_limit = 0;
        self.special_fields.clear();
    }

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

impl ::protobuf::MessageFull for UpdateEnergyLimitContract {
    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("UpdateEnergyLimitContract").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.SmartContractDataWrapper)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SmartContractDataWrapper {
    // message fields
    // @@protoc_insertion_point(field:protocol.SmartContractDataWrapper.smart_contract)
    pub smart_contract: ::protobuf::MessageField<SmartContract>,
    // @@protoc_insertion_point(field:protocol.SmartContractDataWrapper.runtimecode)
    pub runtimecode: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SmartContractDataWrapper.contract_state)
    pub contract_state: ::protobuf::MessageField<ContractState>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.SmartContractDataWrapper.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl SmartContractDataWrapper {
    pub fn new() -> SmartContractDataWrapper {
        ::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::<_, SmartContract>(
            "smart_contract",
            |m: &SmartContractDataWrapper| { &m.smart_contract },
            |m: &mut SmartContractDataWrapper| { &mut m.smart_contract },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "runtimecode",
            |m: &SmartContractDataWrapper| { &m.runtimecode },
            |m: &mut SmartContractDataWrapper| { &mut m.runtimecode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ContractState>(
            "contract_state",
            |m: &SmartContractDataWrapper| { &m.contract_state },
            |m: &mut SmartContractDataWrapper| { &mut m.contract_state },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SmartContractDataWrapper>(
            "SmartContractDataWrapper",
            fields,
            oneofs,
        )
    }
}

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

    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.smart_contract)?;
                },
                18 => {
                    self.runtimecode = is.read_bytes()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.contract_state)?;
                },
                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.smart_contract.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.runtimecode.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.runtimecode);
        }
        if let Some(v) = self.contract_state.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.smart_contract.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if !self.runtimecode.is_empty() {
            os.write_bytes(2, &self.runtimecode)?;
        }
        if let Some(v) = self.contract_state.as_ref() {
            ::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() -> SmartContractDataWrapper {
        SmartContractDataWrapper::new()
    }

    fn clear(&mut self) {
        self.smart_contract.clear();
        self.runtimecode.clear();
        self.contract_state.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SmartContractDataWrapper {
        static instance: SmartContractDataWrapper = SmartContractDataWrapper {
            smart_contract: ::protobuf::MessageField::none(),
            runtimecode: ::std::vec::Vec::new(),
            contract_state: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for SmartContractDataWrapper {
    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("SmartContractDataWrapper").unwrap()).clone()
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\"core/contract/smart_contract.proto\x12\x08protocol\x1a\x0fcore/Tron.\
    proto\"\xa0\t\n\rSmartContract\x12%\n\x0eorigin_address\x18\x01\x20\x01(\
    \x0cR\roriginAddress\x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\
    \x0fcontractAddress\x12-\n\x03abi\x18\x03\x20\x01(\x0b2\x1b.protocol.Sma\
    rtContract.ABIR\x03abi\x12\x1a\n\x08bytecode\x18\x04\x20\x01(\x0cR\x08by\
    tecode\x12\x1d\n\ncall_value\x18\x05\x20\x01(\x03R\tcallValue\x12A\n\x1d\
    consume_user_resource_percent\x18\x06\x20\x01(\x03R\x1aconsumeUserResour\
    cePercent\x12\x12\n\x04name\x18\x07\x20\x01(\tR\x04name\x12.\n\x13origin\
    _energy_limit\x18\x08\x20\x01(\x03R\x11originEnergyLimit\x12\x1b\n\tcode\
    _hash\x18\t\x20\x01(\x0cR\x08codeHash\x12\x19\n\x08trx_hash\x18\n\x20\
    \x01(\x0cR\x07trxHash\x12\x18\n\x07version\x18\x0b\x20\x01(\x05R\x07vers\
    ion\x1a\xf9\x05\n\x03ABI\x129\n\x06entrys\x18\x01\x20\x03(\x0b2!.protoco\
    l.SmartContract.ABI.EntryR\x06entrys\x1a\xb6\x05\n\x05Entry\x12\x1c\n\ta\
    nonymous\x18\x01\x20\x01(\x08R\tanonymous\x12\x1a\n\x08constant\x18\x02\
    \x20\x01(\x08R\x08constant\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\
    \x12?\n\x06inputs\x18\x04\x20\x03(\x0b2'.protocol.SmartContract.ABI.Entr\
    y.ParamR\x06inputs\x12A\n\x07outputs\x18\x05\x20\x03(\x0b2'.protocol.Sma\
    rtContract.ABI.Entry.ParamR\x07outputs\x12?\n\x04type\x18\x06\x20\x01(\
    \x0e2+.protocol.SmartContract.ABI.Entry.EntryTypeR\x04type\x12\x18\n\x07\
    payable\x18\x07\x20\x01(\x08R\x07payable\x12_\n\x0fstateMutability\x18\
    \x08\x20\x01(\x0e25.protocol.SmartContract.ABI.Entry.StateMutabilityType\
    R\x0fstateMutability\x1aI\n\x05Param\x12\x18\n\x07indexed\x18\x01\x20\
    \x01(\x08R\x07indexed\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\
    \x12\n\x04type\x18\x03\x20\x01(\tR\x04type\"q\n\tEntryType\x12\x14\n\x10\
    UnknownEntryType\x10\0\x12\x0f\n\x0bConstructor\x10\x01\x12\x0c\n\x08Fun\
    ction\x10\x02\x12\t\n\x05Event\x10\x03\x12\x0c\n\x08Fallback\x10\x04\x12\
    \x0b\n\x07Receive\x10\x05\x12\t\n\x05Error\x10\x06\"a\n\x13StateMutabili\
    tyType\x12\x19\n\x15UnknownMutabilityType\x10\0\x12\x08\n\x04Pure\x10\
    \x01\x12\x08\n\x04View\x10\x02\x12\x0e\n\nNonpayable\x10\x03\x12\x0b\n\
    \x07Payable\x10\x04\"z\n\rContractState\x12!\n\x0cenergy_usage\x18\x01\
    \x20\x01(\x03R\x0benergyUsage\x12#\n\renergy_factor\x18\x02\x20\x01(\x03\
    R\x0cenergyFactor\x12!\n\x0cupdate_cycle\x18\x03\x20\x01(\x03R\x0bupdate\
    Cycle\"\xbb\x01\n\x13CreateSmartContract\x12#\n\rowner_address\x18\x01\
    \x20\x01(\x0cR\x0cownerAddress\x12:\n\x0cnew_contract\x18\x02\x20\x01(\
    \x0b2\x17.protocol.SmartContractR\x0bnewContract\x12(\n\x10call_token_va\
    lue\x18\x03\x20\x01(\x03R\x0ecallTokenValue\x12\x19\n\x08token_id\x18\
    \x04\x20\x01(\x03R\x07tokenId\"\xde\x01\n\x14TriggerSmartContract\x12#\n\
    \rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddress\x12)\n\x10contract\
    _address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\x12\x1d\n\ncall_value\
    \x18\x03\x20\x01(\x03R\tcallValue\x12\x12\n\x04data\x18\x04\x20\x01(\x0c\
    R\x04data\x12(\n\x10call_token_value\x18\x05\x20\x01(\x03R\x0ecallTokenV\
    alue\x12\x19\n\x08token_id\x18\x06\x20\x01(\x03R\x07tokenId\"b\n\x10Clea\
    rABIContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddress\
    \x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\"\
    \xaa\x01\n\x15UpdateSettingContract\x12#\n\rowner_address\x18\x01\x20\
    \x01(\x0cR\x0cownerAddress\x12)\n\x10contract_address\x18\x02\x20\x01(\
    \x0cR\x0fcontractAddress\x12A\n\x1dconsume_user_resource_percent\x18\x03\
    \x20\x01(\x03R\x1aconsumeUserResourcePercent\"\x9b\x01\n\x19UpdateEnergy\
    LimitContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddres\
    s\x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\
    \x12.\n\x13origin_energy_limit\x18\x03\x20\x01(\x03R\x11originEnergyLimi\
    t\"\xbc\x01\n\x18SmartContractDataWrapper\x12>\n\x0esmart_contract\x18\
    \x01\x20\x01(\x0b2\x17.protocol.SmartContractR\rsmartContract\x12\x20\n\
    \x0bruntimecode\x18\x02\x20\x01(\x0cR\x0bruntimecode\x12>\n\x0econtract_\
    state\x18\x03\x20\x01(\x0b2\x17.protocol.ContractStateR\rcontractStateBE\
    \n\x18org.tron.protos.contractZ)github.com/tronprotocol/grpc-gateway/cor\
    eJ\xde\x20\n\x06\x12\x04\0\0g\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\x20\
    that\x20generated\x20the\x20Java\x20file\n\n\x08\n\x01\x08\x12\x03\x06\0\
    @\nt\n\x02\x08\x0b\x12\x03\x06\0@\x1aioption\x20java_outer_classname\x20\
    =\x20\"CreateSmartContract\";\x20//Specify\x20the\x20class\x20name\x20of\
    \x20the\x20generated\x20Java\x20file\n\n\t\n\x02\x03\0\x12\x03\x08\0\x19\
    \n\n\n\x02\x04\0\x12\x04\n\0:\x01\n\n\n\x03\x04\0\x01\x12\x03\n\x08\x15\
    \n\x0c\n\x04\x04\0\x03\0\x12\x04\x0b\x02.\x03\n\x0c\n\x05\x04\0\x03\0\
    \x01\x12\x03\x0b\n\r\n\x0e\n\x06\x04\0\x03\0\x03\0\x12\x04\x0c\x04,\x05\
    \n\x0e\n\x07\x04\0\x03\0\x03\0\x01\x12\x03\x0c\x0c\x11\n\x10\n\x08\x04\0\
    \x03\0\x03\0\x04\0\x12\x04\r\x06\x15\x07\n\x10\n\t\x04\0\x03\0\x03\0\x04\
    \0\x01\x12\x03\r\x0b\x14\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\0\x12\x03\
    \x0e\x08\x1d\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\0\x01\x12\x03\x0e\
    \x08\x18\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\0\x02\x12\x03\x0e\x1b\
    \x1c\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x01\x12\x03\x0f\x08\x18\n\x12\
    \n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x01\x01\x12\x03\x0f\x08\x13\n\x12\n\
    \x0b\x04\0\x03\0\x03\0\x04\0\x02\x01\x02\x12\x03\x0f\x16\x17\n\x11\n\n\
    \x04\0\x03\0\x03\0\x04\0\x02\x02\x12\x03\x10\x08\x15\n\x12\n\x0b\x04\0\
    \x03\0\x03\0\x04\0\x02\x02\x01\x12\x03\x10\x08\x10\n\x12\n\x0b\x04\0\x03\
    \0\x03\0\x04\0\x02\x02\x02\x12\x03\x10\x13\x14\n\x11\n\n\x04\0\x03\0\x03\
    \0\x04\0\x02\x03\x12\x03\x11\x08\x12\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\
    \x02\x03\x01\x12\x03\x11\x08\r\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\
    \x03\x02\x12\x03\x11\x10\x11\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x04\
    \x12\x03\x12\x08\x15\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x04\x01\x12\
    \x03\x12\x08\x10\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x04\x02\x12\x03\
    \x12\x13\x14\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x05\x12\x03\x13\x08\
    \x14\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x05\x01\x12\x03\x13\x08\x0f\
    \n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x05\x02\x12\x03\x13\x12\x13\n\
    \x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x06\x12\x03\x14\x08\x12\n\x12\n\x0b\
    \x04\0\x03\0\x03\0\x04\0\x02\x06\x01\x12\x03\x14\x08\r\n\x12\n\x0b\x04\0\
    \x03\0\x03\0\x04\0\x02\x06\x02\x12\x03\x14\x10\x11\n\x10\n\x08\x04\0\x03\
    \0\x03\0\x03\0\x12\x04\x16\x06\x1b\x07\n\x10\n\t\x04\0\x03\0\x03\0\x03\0\
    \x01\x12\x03\x16\x0e\x13\n\x11\n\n\x04\0\x03\0\x03\0\x03\0\x02\0\x12\x03\
    \x17\x08\x19\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x05\x12\x03\x17\
    \x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x01\x12\x03\x17\r\x14\
    \n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x03\x12\x03\x17\x17\x18\n\x11\
    \n\n\x04\0\x03\0\x03\0\x03\0\x02\x01\x12\x03\x18\x08\x18\n\x12\n\x0b\x04\
    \0\x03\0\x03\0\x03\0\x02\x01\x05\x12\x03\x18\x08\x0e\n\x12\n\x0b\x04\0\
    \x03\0\x03\0\x03\0\x02\x01\x01\x12\x03\x18\x0f\x13\n\x12\n\x0b\x04\0\x03\
    \0\x03\0\x03\0\x02\x01\x03\x12\x03\x18\x16\x17\n+\n\n\x04\0\x03\0\x03\0\
    \x03\0\x02\x02\x12\x03\x19\x08\x18\"\x18\x20SolidityType\x20type\x20=\
    \x203;\n\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x05\x12\x03\x19\x08\
    \x0e\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x01\x12\x03\x19\x0f\x13\
    \n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x03\x12\x03\x19\x16\x17\n\
    \x10\n\x08\x04\0\x03\0\x03\0\x04\x01\x12\x04\x1c\x06\"\x07\n\x10\n\t\x04\
    \0\x03\0\x03\0\x04\x01\x01\x12\x03\x1c\x0b\x1e\n\x11\n\n\x04\0\x03\0\x03\
    \0\x04\x01\x02\0\x12\x03\x1d\x08\"\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\
    \x02\0\x01\x12\x03\x1d\x08\x1d\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\
    \0\x02\x12\x03\x1d\x20!\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x01\x12\
    \x03\x1e\x08\x11\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x01\x01\x12\
    \x03\x1e\x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x01\x02\x12\
    \x03\x1e\x0f\x10\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x02\x12\x03\x1f\
    \x08\x11\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x02\x01\x12\x03\x1f\
    \x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x02\x02\x12\x03\x1f\
    \x0f\x10\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x03\x12\x03\x20\x08\x17\
    \n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x03\x01\x12\x03\x20\x08\x12\n\
    \x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x03\x02\x12\x03\x20\x15\x16\n\
    \x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x04\x12\x03!\x08\x14\n\x12\n\x0b\
    \x04\0\x03\0\x03\0\x04\x01\x02\x04\x01\x12\x03!\x08\x0f\n\x12\n\x0b\x04\
    \0\x03\0\x03\0\x04\x01\x02\x04\x02\x12\x03!\x12\x13\n\x0f\n\x08\x04\0\
    \x03\0\x03\0\x02\0\x12\x03$\x06\x19\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\
    \x05\x12\x03$\x06\n\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x01\x12\x03$\x0b\
    \x14\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x03\x12\x03$\x17\x18\n\x0f\n\x08\
    \x04\0\x03\0\x03\0\x02\x01\x12\x03%\x06\x18\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x01\x05\x12\x03%\x06\n\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x01\x12\
    \x03%\x0b\x13\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x03\x12\x03%\x16\x17\n\
    \x0f\n\x08\x04\0\x03\0\x03\0\x02\x02\x12\x03&\x06\x16\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\x02\x05\x12\x03&\x06\x0c\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x02\x01\x12\x03&\r\x11\n\x10\n\t\x04\0\x03\0\x03\0\x02\x02\x03\x12\
    \x03&\x14\x15\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x03\x12\x03'\x06\x20\n\
    \x10\n\t\x04\0\x03\0\x03\0\x02\x03\x04\x12\x03'\x06\x0e\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\x03\x06\x12\x03'\x0f\x14\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x03\x01\x12\x03'\x15\x1b\n\x10\n\t\x04\0\x03\0\x03\0\x02\x03\x03\
    \x12\x03'\x1e\x1f\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x04\x12\x03(\x06!\n\
    \x10\n\t\x04\0\x03\0\x03\0\x02\x04\x04\x12\x03(\x06\x0e\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\x04\x06\x12\x03(\x0f\x14\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x04\x01\x12\x03(\x15\x1c\n\x10\n\t\x04\0\x03\0\x03\0\x02\x04\x03\
    \x12\x03(\x1f\x20\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x05\x12\x03)\x06\x19\
    \n\x10\n\t\x04\0\x03\0\x03\0\x02\x05\x06\x12\x03)\x06\x0f\n\x10\n\t\x04\
    \0\x03\0\x03\0\x02\x05\x01\x12\x03)\x10\x14\n\x10\n\t\x04\0\x03\0\x03\0\
    \x02\x05\x03\x12\x03)\x17\x18\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x06\x12\
    \x03*\x06\x17\n\x10\n\t\x04\0\x03\0\x03\0\x02\x06\x05\x12\x03*\x06\n\n\
    \x10\n\t\x04\0\x03\0\x03\0\x02\x06\x01\x12\x03*\x0b\x12\n\x10\n\t\x04\0\
    \x03\0\x03\0\x02\x06\x03\x12\x03*\x15\x16\n\x0f\n\x08\x04\0\x03\0\x03\0\
    \x02\x07\x12\x03+\x06.\n\x10\n\t\x04\0\x03\0\x03\0\x02\x07\x06\x12\x03+\
    \x06\x19\n\x10\n\t\x04\0\x03\0\x03\0\x02\x07\x01\x12\x03+\x1a)\n\x10\n\t\
    \x04\0\x03\0\x03\0\x02\x07\x03\x12\x03+,-\n\r\n\x06\x04\0\x03\0\x02\0\
    \x12\x03-\x04\x1e\n\x0e\n\x07\x04\0\x03\0\x02\0\x04\x12\x03-\x04\x0c\n\
    \x0e\n\x07\x04\0\x03\0\x02\0\x06\x12\x03-\r\x12\n\x0e\n\x07\x04\0\x03\0\
    \x02\0\x01\x12\x03-\x13\x19\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x03-\
    \x1c\x1d\n\x0b\n\x04\x04\0\x02\0\x12\x03/\x02\x1b\n\x0c\n\x05\x04\0\x02\
    \0\x05\x12\x03/\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03/\x08\x16\n\
    \x0c\n\x05\x04\0\x02\0\x03\x12\x03/\x19\x1a\n\x0b\n\x04\x04\0\x02\x01\
    \x12\x030\x02\x1d\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x030\x02\x07\n\x0c\n\
    \x05\x04\0\x02\x01\x01\x12\x030\x08\x18\n\x0c\n\x05\x04\0\x02\x01\x03\
    \x12\x030\x1b\x1c\n\x0b\n\x04\x04\0\x02\x02\x12\x031\x02\x0e\n\x0c\n\x05\
    \x04\0\x02\x02\x06\x12\x031\x02\x05\n\x0c\n\x05\x04\0\x02\x02\x01\x12\
    \x031\x06\t\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x031\x0c\r\n\x0b\n\x04\x04\
    \0\x02\x03\x12\x032\x02\x15\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x032\x02\
    \x07\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x032\x08\x10\n\x0c\n\x05\x04\0\
    \x02\x03\x03\x12\x032\x13\x14\n\x0b\n\x04\x04\0\x02\x04\x12\x033\x02\x17\
    \n\x0c\n\x05\x04\0\x02\x04\x05\x12\x033\x02\x07\n\x0c\n\x05\x04\0\x02\
    \x04\x01\x12\x033\x08\x12\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x033\x15\x16\
    \n\x0b\n\x04\x04\0\x02\x05\x12\x034\x02*\n\x0c\n\x05\x04\0\x02\x05\x05\
    \x12\x034\x02\x07\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x034\x08%\n\x0c\n\
    \x05\x04\0\x02\x05\x03\x12\x034()\n\x0b\n\x04\x04\0\x02\x06\x12\x035\x02\
    \x12\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x035\x02\x08\n\x0c\n\x05\x04\0\
    \x02\x06\x01\x12\x035\t\r\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x035\x10\x11\
    \n\x0b\n\x04\x04\0\x02\x07\x12\x036\x02\x20\n\x0c\n\x05\x04\0\x02\x07\
    \x05\x12\x036\x02\x07\n\x0c\n\x05\x04\0\x02\x07\x01\x12\x036\x08\x1b\n\
    \x0c\n\x05\x04\0\x02\x07\x03\x12\x036\x1e\x1f\n\x0b\n\x04\x04\0\x02\x08\
    \x12\x037\x02\x16\n\x0c\n\x05\x04\0\x02\x08\x05\x12\x037\x02\x07\n\x0c\n\
    \x05\x04\0\x02\x08\x01\x12\x037\x08\x11\n\x0c\n\x05\x04\0\x02\x08\x03\
    \x12\x037\x14\x15\n\x0b\n\x04\x04\0\x02\t\x12\x038\x02\x16\n\x0c\n\x05\
    \x04\0\x02\t\x05\x12\x038\x02\x07\n\x0c\n\x05\x04\0\x02\t\x01\x12\x038\
    \x08\x10\n\x0c\n\x05\x04\0\x02\t\x03\x12\x038\x13\x15\n\x0b\n\x04\x04\0\
    \x02\n\x12\x039\x02\x15\n\x0c\n\x05\x04\0\x02\n\x05\x12\x039\x02\x07\n\
    \x0c\n\x05\x04\0\x02\n\x01\x12\x039\x08\x0f\n\x0c\n\x05\x04\0\x02\n\x03\
    \x12\x039\x12\x14\n\n\n\x02\x04\x01\x12\x04<\0@\x01\n\n\n\x03\x04\x01\
    \x01\x12\x03<\x08\x15\n\x0b\n\x04\x04\x01\x02\0\x12\x03=\x02\x19\n\x0c\n\
    \x05\x04\x01\x02\0\x05\x12\x03=\x02\x07\n\x0c\n\x05\x04\x01\x02\0\x01\
    \x12\x03=\x08\x14\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03=\x17\x18\n\x0b\n\
    \x04\x04\x01\x02\x01\x12\x03>\x02\x1a\n\x0c\n\x05\x04\x01\x02\x01\x05\
    \x12\x03>\x02\x07\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03>\x08\x15\n\x0c\
    \n\x05\x04\x01\x02\x01\x03\x12\x03>\x18\x19\n\x0b\n\x04\x04\x01\x02\x02\
    \x12\x03?\x02\x19\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03?\x02\x07\n\x0c\
    \n\x05\x04\x01\x02\x02\x01\x12\x03?\x08\x14\n\x0c\n\x05\x04\x01\x02\x02\
    \x03\x12\x03?\x17\x18\n\n\n\x02\x04\x02\x12\x04B\0G\x01\n\n\n\x03\x04\
    \x02\x01\x12\x03B\x08\x1b\n\x0b\n\x04\x04\x02\x02\0\x12\x03C\x02\x1a\n\
    \x0c\n\x05\x04\x02\x02\0\x05\x12\x03C\x02\x07\n\x0c\n\x05\x04\x02\x02\0\
    \x01\x12\x03C\x08\x15\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03C\x18\x19\n\
    \x0b\n\x04\x04\x02\x02\x01\x12\x03D\x02!\n\x0c\n\x05\x04\x02\x02\x01\x06\
    \x12\x03D\x02\x0f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03D\x10\x1c\n\x0c\
    \n\x05\x04\x02\x02\x01\x03\x12\x03D\x1f\x20\n\x0b\n\x04\x04\x02\x02\x02\
    \x12\x03E\x02\x1d\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03E\x02\x07\n\x0c\
    \n\x05\x04\x02\x02\x02\x01\x12\x03E\x08\x18\n\x0c\n\x05\x04\x02\x02\x02\
    \x03\x12\x03E\x1b\x1c\n\x0b\n\x04\x04\x02\x02\x03\x12\x03F\x02\x15\n\x0c\
    \n\x05\x04\x02\x02\x03\x05\x12\x03F\x02\x07\n\x0c\n\x05\x04\x02\x02\x03\
    \x01\x12\x03F\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03F\x13\x14\n\
    \n\n\x02\x04\x03\x12\x04I\0P\x01\n\n\n\x03\x04\x03\x01\x12\x03I\x08\x1c\
    \n\x0b\n\x04\x04\x03\x02\0\x12\x03J\x02\x1a\n\x0c\n\x05\x04\x03\x02\0\
    \x05\x12\x03J\x02\x07\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03J\x08\x15\n\
    \x0c\n\x05\x04\x03\x02\0\x03\x12\x03J\x18\x19\n\x0b\n\x04\x04\x03\x02\
    \x01\x12\x03K\x02\x1d\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03K\x02\x07\n\
    \x0c\n\x05\x04\x03\x02\x01\x01\x12\x03K\x08\x18\n\x0c\n\x05\x04\x03\x02\
    \x01\x03\x12\x03K\x1b\x1c\n\x0b\n\x04\x04\x03\x02\x02\x12\x03L\x02\x17\n\
    \x0c\n\x05\x04\x03\x02\x02\x05\x12\x03L\x02\x07\n\x0c\n\x05\x04\x03\x02\
    \x02\x01\x12\x03L\x08\x12\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03L\x15\
    \x16\n\x0b\n\x04\x04\x03\x02\x03\x12\x03M\x02\x11\n\x0c\n\x05\x04\x03\
    \x02\x03\x05\x12\x03M\x02\x07\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03M\
    \x08\x0c\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03M\x0f\x10\n\x0b\n\x04\
    \x04\x03\x02\x04\x12\x03N\x02\x1d\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\
    \x03N\x02\x07\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03N\x08\x18\n\x0c\n\
    \x05\x04\x03\x02\x04\x03\x12\x03N\x1b\x1c\n\x0b\n\x04\x04\x03\x02\x05\
    \x12\x03O\x02\x15\n\x0c\n\x05\x04\x03\x02\x05\x05\x12\x03O\x02\x07\n\x0c\
    \n\x05\x04\x03\x02\x05\x01\x12\x03O\x08\x10\n\x0c\n\x05\x04\x03\x02\x05\
    \x03\x12\x03O\x13\x14\n\n\n\x02\x04\x04\x12\x04R\0U\x01\n\n\n\x03\x04\
    \x04\x01\x12\x03R\x08\x18\n\x0b\n\x04\x04\x04\x02\0\x12\x03S\x02\x1a\n\
    \x0c\n\x05\x04\x04\x02\0\x05\x12\x03S\x02\x07\n\x0c\n\x05\x04\x04\x02\0\
    \x01\x12\x03S\x08\x15\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03S\x18\x19\n\
    \x0b\n\x04\x04\x04\x02\x01\x12\x03T\x02\x1d\n\x0c\n\x05\x04\x04\x02\x01\
    \x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03T\x08\x18\n\
    \x0c\n\x05\x04\x04\x02\x01\x03\x12\x03T\x1b\x1c\n\n\n\x02\x04\x05\x12\
    \x04W\0[\x01\n\n\n\x03\x04\x05\x01\x12\x03W\x08\x1d\n\x0b\n\x04\x04\x05\
    \x02\0\x12\x03X\x02\x1a\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03X\x02\x07\n\
    \x0c\n\x05\x04\x05\x02\0\x01\x12\x03X\x08\x15\n\x0c\n\x05\x04\x05\x02\0\
    \x03\x12\x03X\x18\x19\n\x0b\n\x04\x04\x05\x02\x01\x12\x03Y\x02\x1d\n\x0c\
    \n\x05\x04\x05\x02\x01\x05\x12\x03Y\x02\x07\n\x0c\n\x05\x04\x05\x02\x01\
    \x01\x12\x03Y\x08\x18\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03Y\x1b\x1c\n\
    \x0b\n\x04\x04\x05\x02\x02\x12\x03Z\x02*\n\x0c\n\x05\x04\x05\x02\x02\x05\
    \x12\x03Z\x02\x07\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03Z\x08%\n\x0c\n\
    \x05\x04\x05\x02\x02\x03\x12\x03Z()\n\n\n\x02\x04\x06\x12\x04]\0a\x01\n\
    \n\n\x03\x04\x06\x01\x12\x03]\x08!\n\x0b\n\x04\x04\x06\x02\0\x12\x03^\
    \x02\x1a\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03^\x02\x07\n\x0c\n\x05\x04\
    \x06\x02\0\x01\x12\x03^\x08\x15\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03^\
    \x18\x19\n\x0b\n\x04\x04\x06\x02\x01\x12\x03_\x02\x1d\n\x0c\n\x05\x04\
    \x06\x02\x01\x05\x12\x03_\x02\x07\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\
    \x03_\x08\x18\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03_\x1b\x1c\n\x0b\n\
    \x04\x04\x06\x02\x02\x12\x03`\x02\x20\n\x0c\n\x05\x04\x06\x02\x02\x05\
    \x12\x03`\x02\x07\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\x03`\x08\x1b\n\x0c\
    \n\x05\x04\x06\x02\x02\x03\x12\x03`\x1e\x1f\n\n\n\x02\x04\x07\x12\x04c\0\
    g\x01\n\n\n\x03\x04\x07\x01\x12\x03c\x08\x20\n\x0b\n\x04\x04\x07\x02\0\
    \x12\x03d\x02#\n\x0c\n\x05\x04\x07\x02\0\x06\x12\x03d\x02\x0f\n\x0c\n\
    \x05\x04\x07\x02\0\x01\x12\x03d\x10\x1e\n\x0c\n\x05\x04\x07\x02\0\x03\
    \x12\x03d!\"\n\x0b\n\x04\x04\x07\x02\x01\x12\x03e\x02\x18\n\x0c\n\x05\
    \x04\x07\x02\x01\x05\x12\x03e\x02\x07\n\x0c\n\x05\x04\x07\x02\x01\x01\
    \x12\x03e\x08\x13\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03e\x16\x17\n\x0b\
    \n\x04\x04\x07\x02\x02\x12\x03f\x02#\n\x0c\n\x05\x04\x07\x02\x02\x06\x12\
    \x03f\x02\x0f\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03f\x10\x1e\n\x0c\n\
    \x05\x04\x07\x02\x02\x03\x12\x03f!\"b\x06proto3\
";

/// `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::Tron::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(11);
            messages.push(SmartContract::generated_message_descriptor_data());
            messages.push(ContractState::generated_message_descriptor_data());
            messages.push(CreateSmartContract::generated_message_descriptor_data());
            messages.push(TriggerSmartContract::generated_message_descriptor_data());
            messages.push(ClearABIContract::generated_message_descriptor_data());
            messages.push(UpdateSettingContract::generated_message_descriptor_data());
            messages.push(UpdateEnergyLimitContract::generated_message_descriptor_data());
            messages.push(SmartContractDataWrapper::generated_message_descriptor_data());
            messages.push(smart_contract::ABI::generated_message_descriptor_data());
            messages.push(smart_contract::abi::Entry::generated_message_descriptor_data());
            messages.push(smart_contract::abi::entry::Param::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(2);
            enums.push(smart_contract::abi::entry::EntryType::generated_enum_descriptor_data());
            enums.push(smart_contract::abi::entry::StateMutabilityType::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}