anychain_tron/protocol/

shield_contract.rs

// 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(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/shield_contract.proto`

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

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

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

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

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

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

    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 => {
                    is.read_repeated_packed_bool_into(&mut self.value)?;
                },
                8 => {
                    self.value.push(is.read_bool()?);
                },
                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;
        my_size += 2 * self.value.len() as u64;
        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.value {
            os.write_bool(1, *v)?;
        };
        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() -> AuthenticationPath {
        AuthenticationPath::new()
    }

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

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

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

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

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

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

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

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

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

    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.authentication_paths.push(is.read_message()?);
                },
                18 => {
                    is.read_repeated_packed_bool_into(&mut self.index)?;
                },
                16 => {
                    self.index.push(is.read_bool()?);
                },
                26 => {
                    self.rt = 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;
        for value in &self.authentication_paths {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += 2 * self.index.len() as u64;
        if !self.rt.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.rt);
        }
        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.authentication_paths {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.index {
            os.write_bool(2, *v)?;
        };
        if !self.rt.is_empty() {
            os.write_bytes(3, &self.rt)?;
        }
        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() -> MerklePath {
        MerklePath::new()
    }

    fn clear(&mut self) {
        self.authentication_paths.clear();
        self.index.clear();
        self.rt.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MerklePath {
        static instance: MerklePath = MerklePath {
            authentication_paths: ::std::vec::Vec::new(),
            index: ::std::vec::Vec::new(),
            rt: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.hash = is.read_bytes()?;
                },
                16 => {
                    self.index = 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.hash.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.hash);
        }
        if self.index != 0 {
            my_size += ::protobuf::rt::int32_size(2, self.index);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.hash.is_empty() {
            os.write_bytes(1, &self.hash)?;
        }
        if self.index != 0 {
            os.write_int32(2, self.index)?;
        }
        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() -> OutputPoint {
        OutputPoint::new()
    }

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

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

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

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

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

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

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

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

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

    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.out_points.push(is.read_message()?);
                },
                16 => {
                    self.block_num = 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;
        for value in &self.out_points {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.block_num != 0 {
            my_size += ::protobuf::rt::int32_size(2, self.block_num);
        }
        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.out_points {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if self.block_num != 0 {
            os.write_int32(2, self.block_num)?;
        }
        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() -> OutputPointInfo {
        OutputPointInfo::new()
    }

    fn clear(&mut self) {
        self.out_points.clear();
        self.block_num = 0;
        self.special_fields.clear();
    }

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

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

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

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

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

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

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

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

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

    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.content = 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.content.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.content);
        }
        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.content.is_empty() {
            os.write_bytes(1, &self.content)?;
        }
        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() -> PedersenHash {
        PedersenHash::new()
    }

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

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

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

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

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

// @@protoc_insertion_point(message:protocol.IncrementalMerkleTree)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct IncrementalMerkleTree {
    // message fields
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleTree.left)
    pub left: ::protobuf::MessageField<PedersenHash>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleTree.right)
    pub right: ::protobuf::MessageField<PedersenHash>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleTree.parents)
    pub parents: ::std::vec::Vec<PedersenHash>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.IncrementalMerkleTree.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl IncrementalMerkleTree {
    pub fn new() -> IncrementalMerkleTree {
        ::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::<_, PedersenHash>(
            "left",
            |m: &IncrementalMerkleTree| { &m.left },
            |m: &mut IncrementalMerkleTree| { &mut m.left },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, PedersenHash>(
            "right",
            |m: &IncrementalMerkleTree| { &m.right },
            |m: &mut IncrementalMerkleTree| { &mut m.right },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "parents",
            |m: &IncrementalMerkleTree| { &m.parents },
            |m: &mut IncrementalMerkleTree| { &mut m.parents },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IncrementalMerkleTree>(
            "IncrementalMerkleTree",
            fields,
            oneofs,
        )
    }
}

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

    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.left)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.right)?;
                },
                26 => {
                    self.parents.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.left.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.right.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.parents {
            ::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() -> IncrementalMerkleTree {
        IncrementalMerkleTree::new()
    }

    fn clear(&mut self) {
        self.left.clear();
        self.right.clear();
        self.parents.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static IncrementalMerkleTree {
        static instance: IncrementalMerkleTree = IncrementalMerkleTree {
            left: ::protobuf::MessageField::none(),
            right: ::protobuf::MessageField::none(),
            parents: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

// @@protoc_insertion_point(message:protocol.IncrementalMerkleVoucher)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct IncrementalMerkleVoucher {
    // message fields
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.tree)
    pub tree: ::protobuf::MessageField<IncrementalMerkleTree>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.filled)
    pub filled: ::std::vec::Vec<PedersenHash>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.cursor)
    pub cursor: ::protobuf::MessageField<IncrementalMerkleTree>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.cursor_depth)
    pub cursor_depth: i64,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.rt)
    pub rt: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.IncrementalMerkleVoucher.output_point)
    pub output_point: ::protobuf::MessageField<OutputPoint>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.IncrementalMerkleVoucher.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl IncrementalMerkleVoucher {
    pub fn new() -> IncrementalMerkleVoucher {
        ::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_message_field_accessor::<_, IncrementalMerkleTree>(
            "tree",
            |m: &IncrementalMerkleVoucher| { &m.tree },
            |m: &mut IncrementalMerkleVoucher| { &mut m.tree },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "filled",
            |m: &IncrementalMerkleVoucher| { &m.filled },
            |m: &mut IncrementalMerkleVoucher| { &mut m.filled },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, IncrementalMerkleTree>(
            "cursor",
            |m: &IncrementalMerkleVoucher| { &m.cursor },
            |m: &mut IncrementalMerkleVoucher| { &mut m.cursor },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "cursor_depth",
            |m: &IncrementalMerkleVoucher| { &m.cursor_depth },
            |m: &mut IncrementalMerkleVoucher| { &mut m.cursor_depth },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "rt",
            |m: &IncrementalMerkleVoucher| { &m.rt },
            |m: &mut IncrementalMerkleVoucher| { &mut m.rt },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, OutputPoint>(
            "output_point",
            |m: &IncrementalMerkleVoucher| { &m.output_point },
            |m: &mut IncrementalMerkleVoucher| { &mut m.output_point },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IncrementalMerkleVoucher>(
            "IncrementalMerkleVoucher",
            fields,
            oneofs,
        )
    }
}

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

    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.tree)?;
                },
                18 => {
                    self.filled.push(is.read_message()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.cursor)?;
                },
                32 => {
                    self.cursor_depth = is.read_int64()?;
                },
                42 => {
                    self.rt = is.read_bytes()?;
                },
                82 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.output_point)?;
                },
                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.tree.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.filled {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.cursor.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.cursor_depth != 0 {
            my_size += ::protobuf::rt::int64_size(4, self.cursor_depth);
        }
        if !self.rt.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.rt);
        }
        if let Some(v) = self.output_point.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.tree.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.filled {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.cursor.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if self.cursor_depth != 0 {
            os.write_int64(4, self.cursor_depth)?;
        }
        if !self.rt.is_empty() {
            os.write_bytes(5, &self.rt)?;
        }
        if let Some(v) = self.output_point.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(10, 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() -> IncrementalMerkleVoucher {
        IncrementalMerkleVoucher::new()
    }

    fn clear(&mut self) {
        self.tree.clear();
        self.filled.clear();
        self.cursor.clear();
        self.cursor_depth = 0;
        self.rt.clear();
        self.output_point.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static IncrementalMerkleVoucher {
        static instance: IncrementalMerkleVoucher = IncrementalMerkleVoucher {
            tree: ::protobuf::MessageField::none(),
            filled: ::std::vec::Vec::new(),
            cursor: ::protobuf::MessageField::none(),
            cursor_depth: 0,
            rt: ::std::vec::Vec::new(),
            output_point: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

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

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

impl IncrementalMerkleVoucherInfo {
    pub fn new() -> IncrementalMerkleVoucherInfo {
        ::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_vec_simpler_accessor::<_, _>(
            "vouchers",
            |m: &IncrementalMerkleVoucherInfo| { &m.vouchers },
            |m: &mut IncrementalMerkleVoucherInfo| { &mut m.vouchers },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "paths",
            |m: &IncrementalMerkleVoucherInfo| { &m.paths },
            |m: &mut IncrementalMerkleVoucherInfo| { &mut m.paths },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IncrementalMerkleVoucherInfo>(
            "IncrementalMerkleVoucherInfo",
            fields,
            oneofs,
        )
    }
}

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

    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.vouchers.push(is.read_message()?);
                },
                18 => {
                    self.paths.push(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;
        for value in &self.vouchers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.paths {
            my_size += ::protobuf::rt::bytes_size(2, &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<()> {
        for v in &self.vouchers {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.paths {
            os.write_bytes(2, &v)?;
        };
        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() -> IncrementalMerkleVoucherInfo {
        IncrementalMerkleVoucherInfo::new()
    }

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

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

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

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

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

// @@protoc_insertion_point(message:protocol.SpendDescription)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SpendDescription {
    // message fields
    // @@protoc_insertion_point(field:protocol.SpendDescription.value_commitment)
    pub value_commitment: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SpendDescription.anchor)
    pub anchor: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SpendDescription.nullifier)
    pub nullifier: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SpendDescription.rk)
    pub rk: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SpendDescription.zkproof)
    pub zkproof: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.SpendDescription.spend_authority_signature)
    pub spend_authority_signature: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.SpendDescription.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl SpendDescription {
    pub fn new() -> SpendDescription {
        ::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::<_, _>(
            "value_commitment",
            |m: &SpendDescription| { &m.value_commitment },
            |m: &mut SpendDescription| { &mut m.value_commitment },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "anchor",
            |m: &SpendDescription| { &m.anchor },
            |m: &mut SpendDescription| { &mut m.anchor },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "nullifier",
            |m: &SpendDescription| { &m.nullifier },
            |m: &mut SpendDescription| { &mut m.nullifier },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "rk",
            |m: &SpendDescription| { &m.rk },
            |m: &mut SpendDescription| { &mut m.rk },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "zkproof",
            |m: &SpendDescription| { &m.zkproof },
            |m: &mut SpendDescription| { &mut m.zkproof },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "spend_authority_signature",
            |m: &SpendDescription| { &m.spend_authority_signature },
            |m: &mut SpendDescription| { &mut m.spend_authority_signature },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SpendDescription>(
            "SpendDescription",
            fields,
            oneofs,
        )
    }
}

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

    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.value_commitment = is.read_bytes()?;
                },
                18 => {
                    self.anchor = is.read_bytes()?;
                },
                26 => {
                    self.nullifier = is.read_bytes()?;
                },
                34 => {
                    self.rk = is.read_bytes()?;
                },
                42 => {
                    self.zkproof = is.read_bytes()?;
                },
                50 => {
                    self.spend_authority_signature = 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.value_commitment.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.value_commitment);
        }
        if !self.anchor.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.anchor);
        }
        if !self.nullifier.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.nullifier);
        }
        if !self.rk.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.rk);
        }
        if !self.zkproof.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.zkproof);
        }
        if !self.spend_authority_signature.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.spend_authority_signature);
        }
        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.value_commitment.is_empty() {
            os.write_bytes(1, &self.value_commitment)?;
        }
        if !self.anchor.is_empty() {
            os.write_bytes(2, &self.anchor)?;
        }
        if !self.nullifier.is_empty() {
            os.write_bytes(3, &self.nullifier)?;
        }
        if !self.rk.is_empty() {
            os.write_bytes(4, &self.rk)?;
        }
        if !self.zkproof.is_empty() {
            os.write_bytes(5, &self.zkproof)?;
        }
        if !self.spend_authority_signature.is_empty() {
            os.write_bytes(6, &self.spend_authority_signature)?;
        }
        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() -> SpendDescription {
        SpendDescription::new()
    }

    fn clear(&mut self) {
        self.value_commitment.clear();
        self.anchor.clear();
        self.nullifier.clear();
        self.rk.clear();
        self.zkproof.clear();
        self.spend_authority_signature.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SpendDescription {
        static instance: SpendDescription = SpendDescription {
            value_commitment: ::std::vec::Vec::new(),
            anchor: ::std::vec::Vec::new(),
            nullifier: ::std::vec::Vec::new(),
            rk: ::std::vec::Vec::new(),
            zkproof: ::std::vec::Vec::new(),
            spend_authority_signature: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

// @@protoc_insertion_point(message:protocol.ReceiveDescription)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ReceiveDescription {
    // message fields
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.value_commitment)
    pub value_commitment: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.note_commitment)
    pub note_commitment: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.epk)
    pub epk: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.c_enc)
    pub c_enc: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.c_out)
    pub c_out: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ReceiveDescription.zkproof)
    pub zkproof: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.ReceiveDescription.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl ReceiveDescription {
    pub fn new() -> ReceiveDescription {
        ::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::<_, _>(
            "value_commitment",
            |m: &ReceiveDescription| { &m.value_commitment },
            |m: &mut ReceiveDescription| { &mut m.value_commitment },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "note_commitment",
            |m: &ReceiveDescription| { &m.note_commitment },
            |m: &mut ReceiveDescription| { &mut m.note_commitment },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "epk",
            |m: &ReceiveDescription| { &m.epk },
            |m: &mut ReceiveDescription| { &mut m.epk },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "c_enc",
            |m: &ReceiveDescription| { &m.c_enc },
            |m: &mut ReceiveDescription| { &mut m.c_enc },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "c_out",
            |m: &ReceiveDescription| { &m.c_out },
            |m: &mut ReceiveDescription| { &mut m.c_out },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "zkproof",
            |m: &ReceiveDescription| { &m.zkproof },
            |m: &mut ReceiveDescription| { &mut m.zkproof },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ReceiveDescription>(
            "ReceiveDescription",
            fields,
            oneofs,
        )
    }
}

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

    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.value_commitment = is.read_bytes()?;
                },
                18 => {
                    self.note_commitment = is.read_bytes()?;
                },
                26 => {
                    self.epk = is.read_bytes()?;
                },
                34 => {
                    self.c_enc = is.read_bytes()?;
                },
                42 => {
                    self.c_out = is.read_bytes()?;
                },
                50 => {
                    self.zkproof = 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.value_commitment.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.value_commitment);
        }
        if !self.note_commitment.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.note_commitment);
        }
        if !self.epk.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.epk);
        }
        if !self.c_enc.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.c_enc);
        }
        if !self.c_out.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.c_out);
        }
        if !self.zkproof.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.zkproof);
        }
        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.value_commitment.is_empty() {
            os.write_bytes(1, &self.value_commitment)?;
        }
        if !self.note_commitment.is_empty() {
            os.write_bytes(2, &self.note_commitment)?;
        }
        if !self.epk.is_empty() {
            os.write_bytes(3, &self.epk)?;
        }
        if !self.c_enc.is_empty() {
            os.write_bytes(4, &self.c_enc)?;
        }
        if !self.c_out.is_empty() {
            os.write_bytes(5, &self.c_out)?;
        }
        if !self.zkproof.is_empty() {
            os.write_bytes(6, &self.zkproof)?;
        }
        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() -> ReceiveDescription {
        ReceiveDescription::new()
    }

    fn clear(&mut self) {
        self.value_commitment.clear();
        self.note_commitment.clear();
        self.epk.clear();
        self.c_enc.clear();
        self.c_out.clear();
        self.zkproof.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ReceiveDescription {
        static instance: ReceiveDescription = ReceiveDescription {
            value_commitment: ::std::vec::Vec::new(),
            note_commitment: ::std::vec::Vec::new(),
            epk: ::std::vec::Vec::new(),
            c_enc: ::std::vec::Vec::new(),
            c_out: ::std::vec::Vec::new(),
            zkproof: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

// @@protoc_insertion_point(message:protocol.ShieldedTransferContract)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShieldedTransferContract {
    // message fields
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.transparent_from_address)
    pub transparent_from_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.from_amount)
    pub from_amount: i64,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.spend_description)
    pub spend_description: ::std::vec::Vec<SpendDescription>,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.receive_description)
    pub receive_description: ::std::vec::Vec<ReceiveDescription>,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.binding_signature)
    pub binding_signature: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.transparent_to_address)
    pub transparent_to_address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.ShieldedTransferContract.to_amount)
    pub to_amount: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.ShieldedTransferContract.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(7);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "transparent_from_address",
            |m: &ShieldedTransferContract| { &m.transparent_from_address },
            |m: &mut ShieldedTransferContract| { &mut m.transparent_from_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "from_amount",
            |m: &ShieldedTransferContract| { &m.from_amount },
            |m: &mut ShieldedTransferContract| { &mut m.from_amount },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "spend_description",
            |m: &ShieldedTransferContract| { &m.spend_description },
            |m: &mut ShieldedTransferContract| { &mut m.spend_description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "receive_description",
            |m: &ShieldedTransferContract| { &m.receive_description },
            |m: &mut ShieldedTransferContract| { &mut m.receive_description },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "binding_signature",
            |m: &ShieldedTransferContract| { &m.binding_signature },
            |m: &mut ShieldedTransferContract| { &mut m.binding_signature },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "transparent_to_address",
            |m: &ShieldedTransferContract| { &m.transparent_to_address },
            |m: &mut ShieldedTransferContract| { &mut m.transparent_to_address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "to_amount",
            |m: &ShieldedTransferContract| { &m.to_amount },
            |m: &mut ShieldedTransferContract| { &mut m.to_amount },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShieldedTransferContract>(
            "ShieldedTransferContract",
            fields,
            oneofs,
        )
    }
}

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

    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.transparent_from_address = is.read_bytes()?;
                },
                16 => {
                    self.from_amount = is.read_int64()?;
                },
                26 => {
                    self.spend_description.push(is.read_message()?);
                },
                34 => {
                    self.receive_description.push(is.read_message()?);
                },
                42 => {
                    self.binding_signature = is.read_bytes()?;
                },
                50 => {
                    self.transparent_to_address = is.read_bytes()?;
                },
                56 => {
                    self.to_amount = is.read_int64()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.transparent_from_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.transparent_from_address);
        }
        if self.from_amount != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.from_amount);
        }
        for value in &self.spend_description {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.receive_description {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if !self.binding_signature.is_empty() {
            my_size += ::protobuf::rt::bytes_size(5, &self.binding_signature);
        }
        if !self.transparent_to_address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.transparent_to_address);
        }
        if self.to_amount != 0 {
            my_size += ::protobuf::rt::int64_size(7, self.to_amount);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.transparent_from_address.is_empty() {
            os.write_bytes(1, &self.transparent_from_address)?;
        }
        if self.from_amount != 0 {
            os.write_int64(2, self.from_amount)?;
        }
        for v in &self.spend_description {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.receive_description {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if !self.binding_signature.is_empty() {
            os.write_bytes(5, &self.binding_signature)?;
        }
        if !self.transparent_to_address.is_empty() {
            os.write_bytes(6, &self.transparent_to_address)?;
        }
        if self.to_amount != 0 {
            os.write_int64(7, self.to_amount)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.transparent_from_address.clear();
        self.from_amount = 0;
        self.spend_description.clear();
        self.receive_description.clear();
        self.binding_signature.clear();
        self.transparent_to_address.clear();
        self.to_amount = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ShieldedTransferContract {
        static instance: ShieldedTransferContract = ShieldedTransferContract {
            transparent_from_address: ::std::vec::Vec::new(),
            from_amount: 0,
            spend_description: ::std::vec::Vec::new(),
            receive_description: ::std::vec::Vec::new(),
            binding_signature: ::std::vec::Vec::new(),
            transparent_to_address: ::std::vec::Vec::new(),
            to_amount: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n#core/contract/shield_contract.proto\x12\x08protocol\"*\n\x12Authentic\
    ationPath\x12\x14\n\x05value\x18\x01\x20\x03(\x08R\x05value\"\x83\x01\n\
    \nMerklePath\x12O\n\x14authentication_paths\x18\x01\x20\x03(\x0b2\x1c.pr\
    otocol.AuthenticationPathR\x13authenticationPaths\x12\x14\n\x05index\x18\
    \x02\x20\x03(\x08R\x05index\x12\x0e\n\x02rt\x18\x03\x20\x01(\x0cR\x02rt\
    \"7\n\x0bOutputPoint\x12\x12\n\x04hash\x18\x01\x20\x01(\x0cR\x04hash\x12\
    \x14\n\x05index\x18\x02\x20\x01(\x05R\x05index\"d\n\x0fOutputPointInfo\
    \x124\n\nout_points\x18\x01\x20\x03(\x0b2\x15.protocol.OutputPointR\tout\
    Points\x12\x1b\n\tblock_num\x18\x02\x20\x01(\x05R\x08blockNum\"(\n\x0cPe\
    dersenHash\x12\x18\n\x07content\x18\x01\x20\x01(\x0cR\x07content\"\xa3\
    \x01\n\x15IncrementalMerkleTree\x12*\n\x04left\x18\x01\x20\x01(\x0b2\x16\
    .protocol.PedersenHashR\x04left\x12,\n\x05right\x18\x02\x20\x01(\x0b2\
    \x16.protocol.PedersenHashR\x05right\x120\n\x07parents\x18\x03\x20\x03(\
    \x0b2\x16.protocol.PedersenHashR\x07parents\"\xa5\x02\n\x18IncrementalMe\
    rkleVoucher\x123\n\x04tree\x18\x01\x20\x01(\x0b2\x1f.protocol.Incrementa\
    lMerkleTreeR\x04tree\x12.\n\x06filled\x18\x02\x20\x03(\x0b2\x16.protocol\
    .PedersenHashR\x06filled\x127\n\x06cursor\x18\x03\x20\x01(\x0b2\x1f.prot\
    ocol.IncrementalMerkleTreeR\x06cursor\x12!\n\x0ccursor_depth\x18\x04\x20\
    \x01(\x03R\x0bcursorDepth\x12\x0e\n\x02rt\x18\x05\x20\x01(\x0cR\x02rt\
    \x128\n\x0coutput_point\x18\n\x20\x01(\x0b2\x15.protocol.OutputPointR\
    \x0boutputPoint\"t\n\x1cIncrementalMerkleVoucherInfo\x12>\n\x08vouchers\
    \x18\x01\x20\x03(\x0b2\".protocol.IncrementalMerkleVoucherR\x08vouchers\
    \x12\x14\n\x05paths\x18\x02\x20\x03(\x0cR\x05paths\"\xd9\x01\n\x10SpendD\
    escription\x12)\n\x10value_commitment\x18\x01\x20\x01(\x0cR\x0fvalueComm\
    itment\x12\x16\n\x06anchor\x18\x02\x20\x01(\x0cR\x06anchor\x12\x1c\n\tnu\
    llifier\x18\x03\x20\x01(\x0cR\tnullifier\x12\x0e\n\x02rk\x18\x04\x20\x01\
    (\x0cR\x02rk\x12\x18\n\x07zkproof\x18\x05\x20\x01(\x0cR\x07zkproof\x12:\
    \n\x19spend_authority_signature\x18\x06\x20\x01(\x0cR\x17spendAuthorityS\
    ignature\"\xbe\x01\n\x12ReceiveDescription\x12)\n\x10value_commitment\
    \x18\x01\x20\x01(\x0cR\x0fvalueCommitment\x12'\n\x0fnote_commitment\x18\
    \x02\x20\x01(\x0cR\x0enoteCommitment\x12\x10\n\x03epk\x18\x03\x20\x01(\
    \x0cR\x03epk\x12\x13\n\x05c_enc\x18\x04\x20\x01(\x0cR\x04cEnc\x12\x13\n\
    \x05c_out\x18\x05\x20\x01(\x0cR\x04cOut\x12\x18\n\x07zkproof\x18\x06\x20\
    \x01(\x0cR\x07zkproof\"\x8d\x03\n\x18ShieldedTransferContract\x128\n\x18\
    transparent_from_address\x18\x01\x20\x01(\x0cR\x16transparentFromAddress\
    \x12\x1f\n\x0bfrom_amount\x18\x02\x20\x01(\x03R\nfromAmount\x12G\n\x11sp\
    end_description\x18\x03\x20\x03(\x0b2\x1a.protocol.SpendDescriptionR\x10\
    spendDescription\x12M\n\x13receive_description\x18\x04\x20\x03(\x0b2\x1c\
    .protocol.ReceiveDescriptionR\x12receiveDescription\x12+\n\x11binding_si\
    gnature\x18\x05\x20\x01(\x0cR\x10bindingSignature\x124\n\x16transparent_\
    to_address\x18\x06\x20\x01(\x0cR\x14transparentToAddress\x12\x1b\n\tto_a\
    mount\x18\x07\x20\x01(\x03R\x08toAmountBE\n\x18org.tron.protos.contractZ\
    )github.com/tronprotocol/grpc-gateway/coreJ\xa5\x18\n\x06\x12\x04\0\0P\
    \x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x11\n\
    \x08\n\x01\x08\x12\x03\x04\01\nH\n\x02\x08\x01\x12\x03\x04\01\"=Specify\
    \x20the\x20name\x20of\x20the\x20package\x20that\x20generated\x20the\x20J\
    ava\x20file\n\n\x08\n\x01\x08\x12\x03\x06\0@\ny\n\x02\x08\x0b\x12\x03\
    \x06\0@\x1anoption\x20java_outer_classname\x20=\x20\"ShieldedTransferCon\
    tract\";\x20//Specify\x20the\x20class\x20name\x20of\x20the\x20generated\
    \x20Java\x20file\n\n&\n\x02\x04\0\x12\x04\n\0\x0c\x012\x1a\x20for\x20shi\
    elded\x20transaction\n\n\n\n\x03\x04\0\x01\x12\x03\n\x08\x1a\n\x0b\n\x04\
    \x04\0\x02\0\x12\x03\x0b\x02\x1a\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\x0b\
    \x02\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0b\x0b\x0f\n\x0c\n\x05\x04\0\
    \x02\0\x01\x12\x03\x0b\x10\x15\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x0b\
    \x18\x19\n\n\n\x02\x04\x01\x12\x04\x0e\0\x12\x01\n\n\n\x03\x04\x01\x01\
    \x12\x03\x0e\x08\x12\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x0f\x027\n\x0c\n\
    \x05\x04\x01\x02\0\x04\x12\x03\x0f\x02\n\n\x0c\n\x05\x04\x01\x02\0\x06\
    \x12\x03\x0f\x0b\x1d\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x0f\x1e2\n\
    \x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x0f56\n\x0b\n\x04\x04\x01\x02\x01\
    \x12\x03\x10\x02\x1a\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\x10\x02\n\n\
    \x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x10\x0b\x0f\n\x0c\n\x05\x04\x01\
    \x02\x01\x01\x12\x03\x10\x10\x15\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\
    \x10\x18\x19\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x11\x02\x0f\n\x0c\n\x05\
    \x04\x01\x02\x02\x05\x12\x03\x11\x02\x07\n\x0c\n\x05\x04\x01\x02\x02\x01\
    \x12\x03\x11\x08\n\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x11\r\x0e\n\n\
    \n\x02\x04\x02\x12\x04\x14\0\x17\x01\n\n\n\x03\x04\x02\x01\x12\x03\x14\
    \x08\x13\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x15\x02\x11\n\x0c\n\x05\x04\
    \x02\x02\0\x05\x12\x03\x15\x02\x07\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\
    \x15\x08\x0c\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x15\x0f\x10\n\x0b\n\
    \x04\x04\x02\x02\x01\x12\x03\x16\x02\x12\n\x0c\n\x05\x04\x02\x02\x01\x05\
    \x12\x03\x16\x02\x07\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x16\x08\r\n\
    \x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x16\x10\x11\n\n\n\x02\x04\x03\x12\
    \x04\x19\0\x1c\x01\n\n\n\x03\x04\x03\x01\x12\x03\x19\x08\x17\n\x0b\n\x04\
    \x04\x03\x02\0\x12\x03\x1a\x02&\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03\
    \x1a\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03\x1a\x0b\x16\n\x0c\n\x05\
    \x04\x03\x02\0\x01\x12\x03\x1a\x17!\n\x0c\n\x05\x04\x03\x02\0\x03\x12\
    \x03\x1a$%\n\x0b\n\x04\x04\x03\x02\x01\x12\x03\x1b\x02\x16\n\x0c\n\x05\
    \x04\x03\x02\x01\x05\x12\x03\x1b\x02\x07\n\x0c\n\x05\x04\x03\x02\x01\x01\
    \x12\x03\x1b\x08\x11\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03\x1b\x14\x15\
    \n\n\n\x02\x04\x04\x12\x04\x1e\0\x20\x01\n\n\n\x03\x04\x04\x01\x12\x03\
    \x1e\x08\x14\n\x0b\n\x04\x04\x04\x02\0\x12\x03\x1f\x02\x14\n\x0c\n\x05\
    \x04\x04\x02\0\x05\x12\x03\x1f\x02\x07\n\x0c\n\x05\x04\x04\x02\0\x01\x12\
    \x03\x1f\x08\x0f\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03\x1f\x12\x13\n\n\n\
    \x02\x04\x05\x12\x04\"\0&\x01\n\n\n\x03\x04\x05\x01\x12\x03\"\x08\x1d\n\
    \x0b\n\x04\x04\x05\x02\0\x12\x03#\x02\x18\n\x0c\n\x05\x04\x05\x02\0\x06\
    \x12\x03#\x02\x0e\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03#\x0f\x13\n\x0c\n\
    \x05\x04\x05\x02\0\x03\x12\x03#\x16\x17\n\x0b\n\x04\x04\x05\x02\x01\x12\
    \x03$\x02\x19\n\x0c\n\x05\x04\x05\x02\x01\x06\x12\x03$\x02\x0e\n\x0c\n\
    \x05\x04\x05\x02\x01\x01\x12\x03$\x0f\x14\n\x0c\n\x05\x04\x05\x02\x01\
    \x03\x12\x03$\x17\x18\n\x0b\n\x04\x04\x05\x02\x02\x12\x03%\x02$\n\x0c\n\
    \x05\x04\x05\x02\x02\x04\x12\x03%\x02\n\n\x0c\n\x05\x04\x05\x02\x02\x06\
    \x12\x03%\x0b\x17\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03%\x18\x1f\n\x0c\
    \n\x05\x04\x05\x02\x02\x03\x12\x03%\"#\n\n\n\x02\x04\x06\x12\x04(\0/\x01\
    \n\n\n\x03\x04\x06\x01\x12\x03(\x08\x20\n\x0b\n\x04\x04\x06\x02\0\x12\
    \x03)\x02!\n\x0c\n\x05\x04\x06\x02\0\x06\x12\x03)\x02\x17\n\x0c\n\x05\
    \x04\x06\x02\0\x01\x12\x03)\x18\x1c\n\x0c\n\x05\x04\x06\x02\0\x03\x12\
    \x03)\x1f\x20\n\x0b\n\x04\x04\x06\x02\x01\x12\x03*\x02#\n\x0c\n\x05\x04\
    \x06\x02\x01\x04\x12\x03*\x02\n\n\x0c\n\x05\x04\x06\x02\x01\x06\x12\x03*\
    \x0b\x17\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03*\x18\x1e\n\x0c\n\x05\
    \x04\x06\x02\x01\x03\x12\x03*!\"\n\x0b\n\x04\x04\x06\x02\x02\x12\x03+\
    \x02#\n\x0c\n\x05\x04\x06\x02\x02\x06\x12\x03+\x02\x17\n\x0c\n\x05\x04\
    \x06\x02\x02\x01\x12\x03+\x18\x1e\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\
    \x03+!\"\n\x0b\n\x04\x04\x06\x02\x03\x12\x03,\x02\x19\n\x0c\n\x05\x04\
    \x06\x02\x03\x05\x12\x03,\x02\x07\n\x0c\n\x05\x04\x06\x02\x03\x01\x12\
    \x03,\x08\x14\n\x0c\n\x05\x04\x06\x02\x03\x03\x12\x03,\x17\x18\n\x0b\n\
    \x04\x04\x06\x02\x04\x12\x03-\x02\x0f\n\x0c\n\x05\x04\x06\x02\x04\x05\
    \x12\x03-\x02\x07\n\x0c\n\x05\x04\x06\x02\x04\x01\x12\x03-\x08\n\n\x0c\n\
    \x05\x04\x06\x02\x04\x03\x12\x03-\r\x0e\n\x0b\n\x04\x04\x06\x02\x05\x12\
    \x03.\x02\x20\n\x0c\n\x05\x04\x06\x02\x05\x06\x12\x03.\x02\r\n\x0c\n\x05\
    \x04\x06\x02\x05\x01\x12\x03.\x0e\x1a\n\x0c\n\x05\x04\x06\x02\x05\x03\
    \x12\x03.\x1d\x1f\n\n\n\x02\x04\x07\x12\x041\04\x01\n\n\n\x03\x04\x07\
    \x01\x12\x031\x08$\n\x0b\n\x04\x04\x07\x02\0\x12\x032\x021\n\x0c\n\x05\
    \x04\x07\x02\0\x04\x12\x032\x02\n\n\x0c\n\x05\x04\x07\x02\0\x06\x12\x032\
    \x0b#\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x032$,\n\x0c\n\x05\x04\x07\x02\0\
    \x03\x12\x032/0\n\x0b\n\x04\x04\x07\x02\x01\x12\x033\x02\x1b\n\x0c\n\x05\
    \x04\x07\x02\x01\x04\x12\x033\x02\n\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\
    \x033\x0b\x10\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x033\x11\x16\n\x0c\n\
    \x05\x04\x07\x02\x01\x03\x12\x033\x19\x1a\n\n\n\x02\x04\x08\x12\x046\0=\
    \x01\n\n\n\x03\x04\x08\x01\x12\x036\x08\x18\n\x0b\n\x04\x04\x08\x02\0\
    \x12\x037\x02\x1d\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x037\x02\x07\n\x0c\n\
    \x05\x04\x08\x02\0\x01\x12\x037\x08\x18\n\x0c\n\x05\x04\x08\x02\0\x03\
    \x12\x037\x1b\x1c\n\x1a\n\x04\x04\x08\x02\x01\x12\x038\x02\x13\"\r\x20me\
    rkle\x20root\n\n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x038\x02\x07\n\x0c\n\
    \x05\x04\x08\x02\x01\x01\x12\x038\x08\x0e\n\x0c\n\x05\x04\x08\x02\x01\
    \x03\x12\x038\x11\x12\n*\n\x04\x04\x08\x02\x02\x12\x039\x02\x16\"\x1d\
    \x20used\x20for\x20check\x20double\x20spend\n\n\x0c\n\x05\x04\x08\x02\
    \x02\x05\x12\x039\x02\x07\n\x0c\n\x05\x04\x08\x02\x02\x01\x12\x039\x08\
    \x11\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x039\x14\x15\n7\n\x04\x04\x08\
    \x02\x03\x12\x03:\x02\x0f\"*\x20used\x20for\x20check\x20spend\x20authori\
    ty\x20signature\n\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03:\x02\x07\n\x0c\
    \n\x05\x04\x08\x02\x03\x01\x12\x03:\x08\n\n\x0c\n\x05\x04\x08\x02\x03\
    \x03\x12\x03:\r\x0e\n\x0b\n\x04\x04\x08\x02\x04\x12\x03;\x02\x14\n\x0c\n\
    \x05\x04\x08\x02\x04\x05\x12\x03;\x02\x07\n\x0c\n\x05\x04\x08\x02\x04\
    \x01\x12\x03;\x08\x0f\n\x0c\n\x05\x04\x08\x02\x04\x03\x12\x03;\x12\x13\n\
    \x0b\n\x04\x04\x08\x02\x05\x12\x03<\x02&\n\x0c\n\x05\x04\x08\x02\x05\x05\
    \x12\x03<\x02\x07\n\x0c\n\x05\x04\x08\x02\x05\x01\x12\x03<\x08!\n\x0c\n\
    \x05\x04\x08\x02\x05\x03\x12\x03<$%\n\n\n\x02\x04\t\x12\x04?\0F\x01\n\n\
    \n\x03\x04\t\x01\x12\x03?\x08\x1a\n\x0b\n\x04\x04\t\x02\0\x12\x03@\x02\
    \x1d\n\x0c\n\x05\x04\t\x02\0\x05\x12\x03@\x02\x07\n\x0c\n\x05\x04\t\x02\
    \0\x01\x12\x03@\x08\x18\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03@\x1b\x1c\n\
    \x0b\n\x04\x04\t\x02\x01\x12\x03A\x02\x1c\n\x0c\n\x05\x04\t\x02\x01\x05\
    \x12\x03A\x02\x07\n\x0c\n\x05\x04\t\x02\x01\x01\x12\x03A\x08\x17\n\x0c\n\
    \x05\x04\t\x02\x01\x03\x12\x03A\x1a\x1b\n\x1d\n\x04\x04\t\x02\x02\x12\
    \x03B\x02\x10\"\x10\x20for\x20Encryption\n\n\x0c\n\x05\x04\t\x02\x02\x05\
    \x12\x03B\x02\x07\n\x0c\n\x05\x04\t\x02\x02\x01\x12\x03B\x08\x0b\n\x0c\n\
    \x05\x04\t\x02\x02\x03\x12\x03B\x0e\x0f\n;\n\x04\x04\t\x02\x03\x12\x03C\
    \x02\x12\".\x20Encryption\x20for\x20incoming,\x20decrypt\x20it\x20with\
    \x20ivk\n\n\x0c\n\x05\x04\t\x02\x03\x05\x12\x03C\x02\x07\n\x0c\n\x05\x04\
    \t\x02\x03\x01\x12\x03C\x08\r\n\x0c\n\x05\x04\t\x02\x03\x03\x12\x03C\x10\
    \x11\n8\n\x04\x04\t\x02\x04\x12\x03D\x02\x12\"+\x20Encryption\x20for\x20\
    audit,\x20decrypt\x20it\x20with\x20ovk\n\n\x0c\n\x05\x04\t\x02\x04\x05\
    \x12\x03D\x02\x07\n\x0c\n\x05\x04\t\x02\x04\x01\x12\x03D\x08\r\n\x0c\n\
    \x05\x04\t\x02\x04\x03\x12\x03D\x10\x11\n\x0b\n\x04\x04\t\x02\x05\x12\
    \x03E\x02\x14\n\x0c\n\x05\x04\t\x02\x05\x05\x12\x03E\x02\x07\n\x0c\n\x05\
    \x04\t\x02\x05\x01\x12\x03E\x08\x0f\n\x0c\n\x05\x04\t\x02\x05\x03\x12\
    \x03E\x12\x13\n\n\n\x02\x04\n\x12\x04H\0P\x01\n\n\n\x03\x04\n\x01\x12\
    \x03H\x08\x20\n\"\n\x04\x04\n\x02\0\x12\x03I\x02%\"\x15\x20transparent\
    \x20address\n\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03I\x02\x07\n\x0c\n\x05\
    \x04\n\x02\0\x01\x12\x03I\x08\x20\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03I#$\
    \n\x0b\n\x04\x04\n\x02\x01\x12\x03J\x02\x18\n\x0c\n\x05\x04\n\x02\x01\
    \x05\x12\x03J\x02\x07\n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03J\x08\x13\n\
    \x0c\n\x05\x04\n\x02\x01\x03\x12\x03J\x16\x17\n\x0b\n\x04\x04\n\x02\x02\
    \x12\x03K\x022\n\x0c\n\x05\x04\n\x02\x02\x04\x12\x03K\x02\n\n\x0c\n\x05\
    \x04\n\x02\x02\x06\x12\x03K\x0b\x1b\n\x0c\n\x05\x04\n\x02\x02\x01\x12\
    \x03K\x1c-\n\x0c\n\x05\x04\n\x02\x02\x03\x12\x03K01\n\x0b\n\x04\x04\n\
    \x02\x03\x12\x03L\x026\n\x0c\n\x05\x04\n\x02\x03\x04\x12\x03L\x02\n\n\
    \x0c\n\x05\x04\n\x02\x03\x06\x12\x03L\x0b\x1d\n\x0c\n\x05\x04\n\x02\x03\
    \x01\x12\x03L\x1e1\n\x0c\n\x05\x04\n\x02\x03\x03\x12\x03L45\n\x0b\n\x04\
    \x04\n\x02\x04\x12\x03M\x02\x1e\n\x0c\n\x05\x04\n\x02\x04\x05\x12\x03M\
    \x02\x07\n\x0c\n\x05\x04\n\x02\x04\x01\x12\x03M\x08\x19\n\x0c\n\x05\x04\
    \n\x02\x04\x03\x12\x03M\x1c\x1d\n\"\n\x04\x04\n\x02\x05\x12\x03N\x02#\"\
    \x15\x20transparent\x20address\n\n\x0c\n\x05\x04\n\x02\x05\x05\x12\x03N\
    \x02\x07\n\x0c\n\x05\x04\n\x02\x05\x01\x12\x03N\x08\x1e\n\x0c\n\x05\x04\
    \n\x02\x05\x03\x12\x03N!\"\n3\n\x04\x04\n\x02\x06\x12\x03O\x02\x16\"&\
    \x20the\x20amount\x20to\x20transparent\x20to_address\n\n\x0c\n\x05\x04\n\
    \x02\x06\x05\x12\x03O\x02\x07\n\x0c\n\x05\x04\n\x02\x06\x01\x12\x03O\x08\
    \x11\n\x0c\n\x05\x04\n\x02\x06\x03\x12\x03O\x14\x15b\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(0);
            let mut messages = ::std::vec::Vec::with_capacity(11);
            messages.push(AuthenticationPath::generated_message_descriptor_data());
            messages.push(MerklePath::generated_message_descriptor_data());
            messages.push(OutputPoint::generated_message_descriptor_data());
            messages.push(OutputPointInfo::generated_message_descriptor_data());
            messages.push(PedersenHash::generated_message_descriptor_data());
            messages.push(IncrementalMerkleTree::generated_message_descriptor_data());
            messages.push(IncrementalMerkleVoucher::generated_message_descriptor_data());
            messages.push(IncrementalMerkleVoucherInfo::generated_message_descriptor_data());
            messages.push(SpendDescription::generated_message_descriptor_data());
            messages.push(ReceiveDescription::generated_message_descriptor_data());
            messages.push(ShieldedTransferContract::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}