emerald-wallet-state 0.1.0

// This file is generated by rust-protobuf 2.25.2. Do not edit
// @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_imports)]
#![allow(unused_results)]
//! Generated file from `transactions.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct Transaction {
    // message fields
    pub blockchain: BlockchainId,
    pub tx_id: ::std::string::String,
    pub since_timestamp: u64,
    pub sync_timestamp: u64,
    pub confirm_timestamp: u64,
    pub state: State,
    pub block: ::protobuf::SingularPtrField<BlockRef>,
    pub status: Status,
    pub changes: ::protobuf::RepeatedField<Change>,
    pub version: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .emerald.state.BlockchainId blockchain = 1;


    pub fn get_blockchain(&self) -> BlockchainId {
        self.blockchain
    }
    pub fn clear_blockchain(&mut self) {
        self.blockchain = BlockchainId::CHAIN_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_blockchain(&mut self, v: BlockchainId) {
        self.blockchain = v;
    }

    // string tx_id = 2;


    pub fn get_tx_id(&self) -> &str {
        &self.tx_id
    }
    pub fn clear_tx_id(&mut self) {
        self.tx_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_tx_id(&mut self, v: ::std::string::String) {
        self.tx_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tx_id(&mut self) -> &mut ::std::string::String {
        &mut self.tx_id
    }

    // Take field
    pub fn take_tx_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tx_id, ::std::string::String::new())
    }

    // uint64 since_timestamp = 3;


    pub fn get_since_timestamp(&self) -> u64 {
        self.since_timestamp
    }
    pub fn clear_since_timestamp(&mut self) {
        self.since_timestamp = 0;
    }

    // Param is passed by value, moved
    pub fn set_since_timestamp(&mut self, v: u64) {
        self.since_timestamp = v;
    }

    // uint64 sync_timestamp = 4;


    pub fn get_sync_timestamp(&self) -> u64 {
        self.sync_timestamp
    }
    pub fn clear_sync_timestamp(&mut self) {
        self.sync_timestamp = 0;
    }

    // Param is passed by value, moved
    pub fn set_sync_timestamp(&mut self, v: u64) {
        self.sync_timestamp = v;
    }

    // uint64 confirm_timestamp = 5;


    pub fn get_confirm_timestamp(&self) -> u64 {
        self.confirm_timestamp
    }
    pub fn clear_confirm_timestamp(&mut self) {
        self.confirm_timestamp = 0;
    }

    // Param is passed by value, moved
    pub fn set_confirm_timestamp(&mut self, v: u64) {
        self.confirm_timestamp = v;
    }

    // .emerald.state.State state = 6;


    pub fn get_state(&self) -> State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = State::PREPARED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: State) {
        self.state = v;
    }

    // .emerald.state.BlockRef block = 7;


    pub fn get_block(&self) -> &BlockRef {
        self.block.as_ref().unwrap_or_else(|| <BlockRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_block(&mut self) {
        self.block.clear();
    }

    pub fn has_block(&self) -> bool {
        self.block.is_some()
    }

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

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

    // Take field
    pub fn take_block(&mut self) -> BlockRef {
        self.block.take().unwrap_or_else(|| BlockRef::new())
    }

    // .emerald.state.Status status = 8;


    pub fn get_status(&self) -> Status {
        self.status
    }
    pub fn clear_status(&mut self) {
        self.status = Status::UNKNOWN;
    }

    // Param is passed by value, moved
    pub fn set_status(&mut self, v: Status) {
        self.status = v;
    }

    // repeated .emerald.state.Change changes = 9;


    pub fn get_changes(&self) -> &[Change] {
        &self.changes
    }
    pub fn clear_changes(&mut self) {
        self.changes.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_changes(&mut self) -> &mut ::protobuf::RepeatedField<Change> {
        &mut self.changes
    }

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

    // uint64 version = 10;


    pub fn get_version(&self) -> u64 {
        self.version
    }
    pub fn clear_version(&mut self) {
        self.version = 0;
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: u64) {
        self.version = v;
    }
}

impl ::protobuf::Message for Transaction {
    fn is_initialized(&self) -> bool {
        for v in &self.block {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.changes {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.blockchain, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tx_id)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.since_timestamp = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.sync_timestamp = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.confirm_timestamp = tmp;
                },
                6 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 6, &mut self.unknown_fields)?
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.block)?;
                },
                8 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.status, 8, &mut self.unknown_fields)?
                },
                9 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.changes)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.version = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.blockchain != BlockchainId::CHAIN_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.blockchain);
        }
        if !self.tx_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.tx_id);
        }
        if self.since_timestamp != 0 {
            my_size += ::protobuf::rt::value_size(3, self.since_timestamp, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.sync_timestamp != 0 {
            my_size += ::protobuf::rt::value_size(4, self.sync_timestamp, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.confirm_timestamp != 0 {
            my_size += ::protobuf::rt::value_size(5, self.confirm_timestamp, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.state != State::PREPARED {
            my_size += ::protobuf::rt::enum_size(6, self.state);
        }
        if let Some(ref v) = self.block.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.status != Status::UNKNOWN {
            my_size += ::protobuf::rt::enum_size(8, self.status);
        }
        for value in &self.changes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(10, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.blockchain != BlockchainId::CHAIN_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.blockchain))?;
        }
        if !self.tx_id.is_empty() {
            os.write_string(2, &self.tx_id)?;
        }
        if self.since_timestamp != 0 {
            os.write_uint64(3, self.since_timestamp)?;
        }
        if self.sync_timestamp != 0 {
            os.write_uint64(4, self.sync_timestamp)?;
        }
        if self.confirm_timestamp != 0 {
            os.write_uint64(5, self.confirm_timestamp)?;
        }
        if self.state != State::PREPARED {
            os.write_enum(6, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if let Some(ref v) = self.block.as_ref() {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.status != Status::UNKNOWN {
            os.write_enum(8, ::protobuf::ProtobufEnum::value(&self.status))?;
        }
        for v in &self.changes {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.version != 0 {
            os.write_uint64(10, self.version)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<BlockchainId>>(
                "blockchain",
                |m: &Transaction| { &m.blockchain },
                |m: &mut Transaction| { &mut m.blockchain },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "tx_id",
                |m: &Transaction| { &m.tx_id },
                |m: &mut Transaction| { &mut m.tx_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "since_timestamp",
                |m: &Transaction| { &m.since_timestamp },
                |m: &mut Transaction| { &mut m.since_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "sync_timestamp",
                |m: &Transaction| { &m.sync_timestamp },
                |m: &mut Transaction| { &mut m.sync_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "confirm_timestamp",
                |m: &Transaction| { &m.confirm_timestamp },
                |m: &mut Transaction| { &mut m.confirm_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<State>>(
                "state",
                |m: &Transaction| { &m.state },
                |m: &mut Transaction| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlockRef>>(
                "block",
                |m: &Transaction| { &m.block },
                |m: &mut Transaction| { &mut m.block },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Status>>(
                "status",
                |m: &Transaction| { &m.status },
                |m: &mut Transaction| { &mut m.status },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Change>>(
                "changes",
                |m: &Transaction| { &m.changes },
                |m: &mut Transaction| { &mut m.changes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "version",
                |m: &Transaction| { &m.version },
                |m: &mut Transaction| { &mut m.version },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Transaction>(
                "Transaction",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Transaction {
        static instance: ::protobuf::rt::LazyV2<Transaction> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Transaction::new)
    }
}

impl ::protobuf::Clear for Transaction {
    fn clear(&mut self) {
        self.blockchain = BlockchainId::CHAIN_UNSPECIFIED;
        self.tx_id.clear();
        self.since_timestamp = 0;
        self.sync_timestamp = 0;
        self.confirm_timestamp = 0;
        self.state = State::PREPARED;
        self.block.clear();
        self.status = Status::UNKNOWN;
        self.changes.clear();
        self.version = 0;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Transaction {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TransactionMeta {
    // message fields
    pub timestamp: u64,
    pub blockchain: BlockchainId,
    pub tx_id: ::std::string::String,
    pub label: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 timestamp = 1;


    pub fn get_timestamp(&self) -> u64 {
        self.timestamp
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp = 0;
    }

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

    // .emerald.state.BlockchainId blockchain = 2;


    pub fn get_blockchain(&self) -> BlockchainId {
        self.blockchain
    }
    pub fn clear_blockchain(&mut self) {
        self.blockchain = BlockchainId::CHAIN_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_blockchain(&mut self, v: BlockchainId) {
        self.blockchain = v;
    }

    // string tx_id = 3;


    pub fn get_tx_id(&self) -> &str {
        &self.tx_id
    }
    pub fn clear_tx_id(&mut self) {
        self.tx_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_tx_id(&mut self, v: ::std::string::String) {
        self.tx_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tx_id(&mut self) -> &mut ::std::string::String {
        &mut self.tx_id
    }

    // Take field
    pub fn take_tx_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tx_id, ::std::string::String::new())
    }

    // string label = 4;


    pub fn get_label(&self) -> &str {
        &self.label
    }
    pub fn clear_label(&mut self) {
        self.label.clear();
    }

    // Param is passed by value, moved
    pub fn set_label(&mut self, v: ::std::string::String) {
        self.label = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_label(&mut self) -> &mut ::std::string::String {
        &mut self.label
    }

    // Take field
    pub fn take_label(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.label, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TransactionMeta {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.timestamp = tmp;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.blockchain, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tx_id)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.label)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::value_size(1, self.timestamp, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.blockchain != BlockchainId::CHAIN_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.blockchain);
        }
        if !self.tx_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.tx_id);
        }
        if !self.label.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.label);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.timestamp != 0 {
            os.write_uint64(1, self.timestamp)?;
        }
        if self.blockchain != BlockchainId::CHAIN_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.blockchain))?;
        }
        if !self.tx_id.is_empty() {
            os.write_string(3, &self.tx_id)?;
        }
        if !self.label.is_empty() {
            os.write_string(4, &self.label)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "timestamp",
                |m: &TransactionMeta| { &m.timestamp },
                |m: &mut TransactionMeta| { &mut m.timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<BlockchainId>>(
                "blockchain",
                |m: &TransactionMeta| { &m.blockchain },
                |m: &mut TransactionMeta| { &mut m.blockchain },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "tx_id",
                |m: &TransactionMeta| { &m.tx_id },
                |m: &mut TransactionMeta| { &mut m.tx_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "label",
                |m: &TransactionMeta| { &m.label },
                |m: &mut TransactionMeta| { &mut m.label },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionMeta>(
                "TransactionMeta",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TransactionMeta {
        static instance: ::protobuf::rt::LazyV2<TransactionMeta> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TransactionMeta::new)
    }
}

impl ::protobuf::Clear for TransactionMeta {
    fn clear(&mut self) {
        self.timestamp = 0;
        self.blockchain = BlockchainId::CHAIN_UNSPECIFIED;
        self.tx_id.clear();
        self.label.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for TransactionMeta {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct BlockRef {
    // message fields
    pub height: u64,
    pub block_id: ::std::string::String,
    pub timestamp: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 height = 1;


    pub fn get_height(&self) -> u64 {
        self.height
    }
    pub fn clear_height(&mut self) {
        self.height = 0;
    }

    // Param is passed by value, moved
    pub fn set_height(&mut self, v: u64) {
        self.height = v;
    }

    // string block_id = 2;


    pub fn get_block_id(&self) -> &str {
        &self.block_id
    }
    pub fn clear_block_id(&mut self) {
        self.block_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_block_id(&mut self, v: ::std::string::String) {
        self.block_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_block_id(&mut self) -> &mut ::std::string::String {
        &mut self.block_id
    }

    // Take field
    pub fn take_block_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.block_id, ::std::string::String::new())
    }

    // uint64 timestamp = 3;


    pub fn get_timestamp(&self) -> u64 {
        self.timestamp
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp = 0;
    }

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

impl ::protobuf::Message for BlockRef {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.height = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.block_id)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.timestamp = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.height != 0 {
            my_size += ::protobuf::rt::value_size(1, self.height, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.block_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.block_id);
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::value_size(3, self.timestamp, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.height != 0 {
            os.write_uint64(1, self.height)?;
        }
        if !self.block_id.is_empty() {
            os.write_string(2, &self.block_id)?;
        }
        if self.timestamp != 0 {
            os.write_uint64(3, self.timestamp)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "height",
                |m: &BlockRef| { &m.height },
                |m: &mut BlockRef| { &mut m.height },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "block_id",
                |m: &BlockRef| { &m.block_id },
                |m: &mut BlockRef| { &mut m.block_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "timestamp",
                |m: &BlockRef| { &m.timestamp },
                |m: &mut BlockRef| { &mut m.timestamp },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BlockRef>(
                "BlockRef",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BlockRef {
        static instance: ::protobuf::rt::LazyV2<BlockRef> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BlockRef::new)
    }
}

impl ::protobuf::Clear for BlockRef {
    fn clear(&mut self) {
        self.height = 0;
        self.block_id.clear();
        self.timestamp = 0;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for BlockRef {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Change {
    // message fields
    pub wallet_id: ::std::string::String,
    pub entry_id: u32,
    pub address: ::std::string::String,
    pub hd_path: ::std::string::String,
    pub asset: ::std::string::String,
    pub amount: ::std::string::String,
    pub change_type: Change_ChangeType,
    pub direction: Direction,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string wallet_id = 1;


    pub fn get_wallet_id(&self) -> &str {
        &self.wallet_id
    }
    pub fn clear_wallet_id(&mut self) {
        self.wallet_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_wallet_id(&mut self, v: ::std::string::String) {
        self.wallet_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_wallet_id(&mut self) -> &mut ::std::string::String {
        &mut self.wallet_id
    }

    // Take field
    pub fn take_wallet_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.wallet_id, ::std::string::String::new())
    }

    // uint32 entry_id = 2;


    pub fn get_entry_id(&self) -> u32 {
        self.entry_id
    }
    pub fn clear_entry_id(&mut self) {
        self.entry_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_entry_id(&mut self, v: u32) {
        self.entry_id = v;
    }

    // string address = 3;


    pub fn get_address(&self) -> &str {
        &self.address
    }
    pub fn clear_address(&mut self) {
        self.address.clear();
    }

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

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

    // Take field
    pub fn take_address(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.address, ::std::string::String::new())
    }

    // string hd_path = 4;


    pub fn get_hd_path(&self) -> &str {
        &self.hd_path
    }
    pub fn clear_hd_path(&mut self) {
        self.hd_path.clear();
    }

    // Param is passed by value, moved
    pub fn set_hd_path(&mut self, v: ::std::string::String) {
        self.hd_path = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_hd_path(&mut self) -> &mut ::std::string::String {
        &mut self.hd_path
    }

    // Take field
    pub fn take_hd_path(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.hd_path, ::std::string::String::new())
    }

    // string asset = 5;


    pub fn get_asset(&self) -> &str {
        &self.asset
    }
    pub fn clear_asset(&mut self) {
        self.asset.clear();
    }

    // Param is passed by value, moved
    pub fn set_asset(&mut self, v: ::std::string::String) {
        self.asset = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_asset(&mut self) -> &mut ::std::string::String {
        &mut self.asset
    }

    // Take field
    pub fn take_asset(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.asset, ::std::string::String::new())
    }

    // string amount = 6;


    pub fn get_amount(&self) -> &str {
        &self.amount
    }
    pub fn clear_amount(&mut self) {
        self.amount.clear();
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_amount(&mut self) -> &mut ::std::string::String {
        &mut self.amount
    }

    // Take field
    pub fn take_amount(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.amount, ::std::string::String::new())
    }

    // .emerald.state.Change.ChangeType change_type = 7;


    pub fn get_change_type(&self) -> Change_ChangeType {
        self.change_type
    }
    pub fn clear_change_type(&mut self) {
        self.change_type = Change_ChangeType::UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_change_type(&mut self, v: Change_ChangeType) {
        self.change_type = v;
    }

    // .emerald.state.Direction direction = 8;


    pub fn get_direction(&self) -> Direction {
        self.direction
    }
    pub fn clear_direction(&mut self) {
        self.direction = Direction::RECEIVE;
    }

    // Param is passed by value, moved
    pub fn set_direction(&mut self, v: Direction) {
        self.direction = v;
    }
}

impl ::protobuf::Message for Change {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.wallet_id)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.entry_id = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.address)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.hd_path)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.asset)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.amount)?;
                },
                7 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.change_type, 7, &mut self.unknown_fields)?
                },
                8 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.direction, 8, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.wallet_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.wallet_id);
        }
        if self.entry_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.entry_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.address.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.address);
        }
        if !self.hd_path.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.hd_path);
        }
        if !self.asset.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.asset);
        }
        if !self.amount.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.amount);
        }
        if self.change_type != Change_ChangeType::UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(7, self.change_type);
        }
        if self.direction != Direction::RECEIVE {
            my_size += ::protobuf::rt::enum_size(8, self.direction);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.wallet_id.is_empty() {
            os.write_string(1, &self.wallet_id)?;
        }
        if self.entry_id != 0 {
            os.write_uint32(2, self.entry_id)?;
        }
        if !self.address.is_empty() {
            os.write_string(3, &self.address)?;
        }
        if !self.hd_path.is_empty() {
            os.write_string(4, &self.hd_path)?;
        }
        if !self.asset.is_empty() {
            os.write_string(5, &self.asset)?;
        }
        if !self.amount.is_empty() {
            os.write_string(6, &self.amount)?;
        }
        if self.change_type != Change_ChangeType::UNSPECIFIED {
            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.change_type))?;
        }
        if self.direction != Direction::RECEIVE {
            os.write_enum(8, ::protobuf::ProtobufEnum::value(&self.direction))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "wallet_id",
                |m: &Change| { &m.wallet_id },
                |m: &mut Change| { &mut m.wallet_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "entry_id",
                |m: &Change| { &m.entry_id },
                |m: &mut Change| { &mut m.entry_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "address",
                |m: &Change| { &m.address },
                |m: &mut Change| { &mut m.address },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "hd_path",
                |m: &Change| { &m.hd_path },
                |m: &mut Change| { &mut m.hd_path },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "asset",
                |m: &Change| { &m.asset },
                |m: &mut Change| { &mut m.asset },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "amount",
                |m: &Change| { &m.amount },
                |m: &mut Change| { &mut m.amount },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Change_ChangeType>>(
                "change_type",
                |m: &Change| { &m.change_type },
                |m: &mut Change| { &mut m.change_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Direction>>(
                "direction",
                |m: &Change| { &m.direction },
                |m: &mut Change| { &mut m.direction },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Change>(
                "Change",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Change {
        static instance: ::protobuf::rt::LazyV2<Change> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Change::new)
    }
}

impl ::protobuf::Clear for Change {
    fn clear(&mut self) {
        self.wallet_id.clear();
        self.entry_id = 0;
        self.address.clear();
        self.hd_path.clear();
        self.asset.clear();
        self.amount.clear();
        self.change_type = Change_ChangeType::UNSPECIFIED;
        self.direction = Direction::RECEIVE;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Change {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Change_ChangeType {
    UNSPECIFIED = 0,
    TRANSFER = 1,
    FEE = 2,
}

impl ::protobuf::ProtobufEnum for Change_ChangeType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Change_ChangeType> {
        match value {
            0 => ::std::option::Option::Some(Change_ChangeType::UNSPECIFIED),
            1 => ::std::option::Option::Some(Change_ChangeType::TRANSFER),
            2 => ::std::option::Option::Some(Change_ChangeType::FEE),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Change_ChangeType] = &[
            Change_ChangeType::UNSPECIFIED,
            Change_ChangeType::TRANSFER,
            Change_ChangeType::FEE,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Change_ChangeType>("Change.ChangeType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for Change_ChangeType {
}

impl ::std::default::Default for Change_ChangeType {
    fn default() -> Self {
        Change_ChangeType::UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for Change_ChangeType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Cursor {
    // message fields
    pub address: ::std::string::String,
    pub value: ::std::string::String,
    pub ts: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string address = 1;


    pub fn get_address(&self) -> &str {
        &self.address
    }
    pub fn clear_address(&mut self) {
        self.address.clear();
    }

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

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

    // Take field
    pub fn take_address(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.address, ::std::string::String::new())
    }

    // string value = 2;


    pub fn get_value(&self) -> &str {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_value(&mut self) -> &mut ::std::string::String {
        &mut self.value
    }

    // Take field
    pub fn take_value(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.value, ::std::string::String::new())
    }

    // uint64 ts = 3;


    pub fn get_ts(&self) -> u64 {
        self.ts
    }
    pub fn clear_ts(&mut self) {
        self.ts = 0;
    }

    // Param is passed by value, moved
    pub fn set_ts(&mut self, v: u64) {
        self.ts = v;
    }
}

impl ::protobuf::Message for Cursor {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.address)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.value)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.ts = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.address.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.address);
        }
        if !self.value.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.value);
        }
        if self.ts != 0 {
            my_size += ::protobuf::rt::value_size(3, self.ts, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.address.is_empty() {
            os.write_string(1, &self.address)?;
        }
        if !self.value.is_empty() {
            os.write_string(2, &self.value)?;
        }
        if self.ts != 0 {
            os.write_uint64(3, self.ts)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "address",
                |m: &Cursor| { &m.address },
                |m: &mut Cursor| { &mut m.address },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "value",
                |m: &Cursor| { &m.value },
                |m: &mut Cursor| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "ts",
                |m: &Cursor| { &m.ts },
                |m: &mut Cursor| { &mut m.ts },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Cursor>(
                "Cursor",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Cursor {
        static instance: ::protobuf::rt::LazyV2<Cursor> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Cursor::new)
    }
}

impl ::protobuf::Clear for Cursor {
    fn clear(&mut self) {
        self.address.clear();
        self.value.clear();
        self.ts = 0;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for Cursor {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum BlockchainId {
    CHAIN_UNSPECIFIED = 0,
    CHAIN_BITCOIN = 1,
    CHAIN_ETHEREUM = 100,
    CHAIN_ETHEREUM_CLASSIC = 101,
    CHAIN_MORDEN = 10001,
    CHAIN_KOVAN = 10002,
    CHAIN_TESTNET_BITCOIN = 10003,
    CHAIN_GOERLI = 10005,
    CHAIN_ROPSTEN = 10006,
    CHAIN_RINKEBY = 10007,
}

impl ::protobuf::ProtobufEnum for BlockchainId {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<BlockchainId> {
        match value {
            0 => ::std::option::Option::Some(BlockchainId::CHAIN_UNSPECIFIED),
            1 => ::std::option::Option::Some(BlockchainId::CHAIN_BITCOIN),
            100 => ::std::option::Option::Some(BlockchainId::CHAIN_ETHEREUM),
            101 => ::std::option::Option::Some(BlockchainId::CHAIN_ETHEREUM_CLASSIC),
            10001 => ::std::option::Option::Some(BlockchainId::CHAIN_MORDEN),
            10002 => ::std::option::Option::Some(BlockchainId::CHAIN_KOVAN),
            10003 => ::std::option::Option::Some(BlockchainId::CHAIN_TESTNET_BITCOIN),
            10005 => ::std::option::Option::Some(BlockchainId::CHAIN_GOERLI),
            10006 => ::std::option::Option::Some(BlockchainId::CHAIN_ROPSTEN),
            10007 => ::std::option::Option::Some(BlockchainId::CHAIN_RINKEBY),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [BlockchainId] = &[
            BlockchainId::CHAIN_UNSPECIFIED,
            BlockchainId::CHAIN_BITCOIN,
            BlockchainId::CHAIN_ETHEREUM,
            BlockchainId::CHAIN_ETHEREUM_CLASSIC,
            BlockchainId::CHAIN_MORDEN,
            BlockchainId::CHAIN_KOVAN,
            BlockchainId::CHAIN_TESTNET_BITCOIN,
            BlockchainId::CHAIN_GOERLI,
            BlockchainId::CHAIN_ROPSTEN,
            BlockchainId::CHAIN_RINKEBY,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<BlockchainId>("BlockchainId", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for BlockchainId {
}

impl ::std::default::Default for BlockchainId {
    fn default() -> Self {
        BlockchainId::CHAIN_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for BlockchainId {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum State {
    PREPARED = 0,
    SUBMITTED = 10,
    REPLACED = 11,
    CONFIRMED = 12,
    DROPPED = 20,
}

impl ::protobuf::ProtobufEnum for State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<State> {
        match value {
            0 => ::std::option::Option::Some(State::PREPARED),
            10 => ::std::option::Option::Some(State::SUBMITTED),
            11 => ::std::option::Option::Some(State::REPLACED),
            12 => ::std::option::Option::Some(State::CONFIRMED),
            20 => ::std::option::Option::Some(State::DROPPED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [State] = &[
            State::PREPARED,
            State::SUBMITTED,
            State::REPLACED,
            State::CONFIRMED,
            State::DROPPED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<State>("State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for State {
}

impl ::std::default::Default for State {
    fn default() -> Self {
        State::PREPARED
    }
}

impl ::protobuf::reflect::ProtobufValue for State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Status {
    UNKNOWN = 0,
    OK = 1,
    FAILED = 2,
}

impl ::protobuf::ProtobufEnum for Status {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Status> {
        match value {
            0 => ::std::option::Option::Some(Status::UNKNOWN),
            1 => ::std::option::Option::Some(Status::OK),
            2 => ::std::option::Option::Some(Status::FAILED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Status] = &[
            Status::UNKNOWN,
            Status::OK,
            Status::FAILED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Status>("Status", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for Status {
}

impl ::std::default::Default for Status {
    fn default() -> Self {
        Status::UNKNOWN
    }
}

impl ::protobuf::reflect::ProtobufValue for Status {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Direction {
    RECEIVE = 0,
    SEND = 1,
}

impl ::protobuf::ProtobufEnum for Direction {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Direction> {
        match value {
            0 => ::std::option::Option::Some(Direction::RECEIVE),
            1 => ::std::option::Option::Some(Direction::SEND),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Direction] = &[
            Direction::RECEIVE,
            Direction::SEND,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Direction>("Direction", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for Direction {
}

impl ::std::default::Default for Direction {
    fn default() -> Self {
        Direction::RECEIVE
    }
}

impl ::protobuf::reflect::ProtobufValue for Direction {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x12transactions.proto\x12\remerald.state\"\xb1\x03\n\x0bTransaction\
    \x12;\n\nblockchain\x18\x01\x20\x01(\x0e2\x1b.emerald.state.BlockchainId\
    R\nblockchain\x12\x13\n\x05tx_id\x18\x02\x20\x01(\tR\x04txId\x12'\n\x0fs\
    ince_timestamp\x18\x03\x20\x01(\x04R\x0esinceTimestamp\x12%\n\x0esync_ti\
    mestamp\x18\x04\x20\x01(\x04R\rsyncTimestamp\x12+\n\x11confirm_timestamp\
    \x18\x05\x20\x01(\x04R\x10confirmTimestamp\x12*\n\x05state\x18\x06\x20\
    \x01(\x0e2\x14.emerald.state.StateR\x05state\x12-\n\x05block\x18\x07\x20\
    \x01(\x0b2\x17.emerald.state.BlockRefR\x05block\x12-\n\x06status\x18\x08\
    \x20\x01(\x0e2\x15.emerald.state.StatusR\x06status\x12/\n\x07changes\x18\
    \t\x20\x03(\x0b2\x15.emerald.state.ChangeR\x07changes\x12\x18\n\x07versi\
    on\x18\n\x20\x01(\x04R\x07version\"\x97\x01\n\x0fTransactionMeta\x12\x1c\
    \n\ttimestamp\x18\x01\x20\x01(\x04R\ttimestamp\x12;\n\nblockchain\x18\
    \x02\x20\x01(\x0e2\x1b.emerald.state.BlockchainIdR\nblockchain\x12\x13\n\
    \x05tx_id\x18\x03\x20\x01(\tR\x04txId\x12\x14\n\x05label\x18\x04\x20\x01\
    (\tR\x05label\"[\n\x08BlockRef\x12\x16\n\x06height\x18\x01\x20\x01(\x04R\
    \x06height\x12\x19\n\x08block_id\x18\x02\x20\x01(\tR\x07blockId\x12\x1c\
    \n\ttimestamp\x18\x03\x20\x01(\x04R\ttimestamp\"\xd2\x02\n\x06Change\x12\
    \x1b\n\twallet_id\x18\x01\x20\x01(\tR\x08walletId\x12\x19\n\x08entry_id\
    \x18\x02\x20\x01(\rR\x07entryId\x12\x18\n\x07address\x18\x03\x20\x01(\tR\
    \x07address\x12\x17\n\x07hd_path\x18\x04\x20\x01(\tR\x06hdPath\x12\x14\n\
    \x05asset\x18\x05\x20\x01(\tR\x05asset\x12\x16\n\x06amount\x18\x06\x20\
    \x01(\tR\x06amount\x12A\n\x0bchange_type\x18\x07\x20\x01(\x0e2\x20.emera\
    ld.state.Change.ChangeTypeR\nchangeType\x126\n\tdirection\x18\x08\x20\
    \x01(\x0e2\x18.emerald.state.DirectionR\tdirection\"4\n\nChangeType\x12\
    \x0f\n\x0bUNSPECIFIED\x10\0\x12\x0c\n\x08TRANSFER\x10\x01\x12\x07\n\x03F\
    EE\x10\x02\"H\n\x06Cursor\x12\x18\n\x07address\x18\x01\x20\x01(\tR\x07ad\
    dress\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value\x12\x0e\n\x02ts\
    \x18\x03\x20\x01(\x04R\x02ts*\xe4\x01\n\x0cBlockchainId\x12\x15\n\x11CHA\
    IN_UNSPECIFIED\x10\0\x12\x11\n\rCHAIN_BITCOIN\x10\x01\x12\x12\n\x0eCHAIN\
    _ETHEREUM\x10d\x12\x1a\n\x16CHAIN_ETHEREUM_CLASSIC\x10e\x12\x11\n\x0cCHA\
    IN_MORDEN\x10\x91N\x12\x10\n\x0bCHAIN_KOVAN\x10\x92N\x12\x1a\n\x15CHAIN_\
    TESTNET_BITCOIN\x10\x93N\x12\x11\n\x0cCHAIN_GOERLI\x10\x95N\x12\x12\n\rC\
    HAIN_ROPSTEN\x10\x96N\x12\x12\n\rCHAIN_RINKEBY\x10\x97N*N\n\x05State\x12\
    \x0c\n\x08PREPARED\x10\0\x12\r\n\tSUBMITTED\x10\n\x12\x0c\n\x08REPLACED\
    \x10\x0b\x12\r\n\tCONFIRMED\x10\x0c\x12\x0b\n\x07DROPPED\x10\x14*)\n\x06\
    Status\x12\x0b\n\x07UNKNOWN\x10\0\x12\x06\n\x02OK\x10\x01\x12\n\n\x06FAI\
    LED\x10\x02*\"\n\tDirection\x12\x0b\n\x07RECEIVE\x10\0\x12\x08\n\x04SEND\
    \x10\x01J\x8f\x17\n\x06\x12\x04\0\0V\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\
    \n\x08\n\x01\x02\x12\x03\x01\0\x16\n\n\n\x02\x04\0\x12\x04\x03\0\x0e\x01\
    \n\n\n\x03\x04\0\x01\x12\x03\x03\x08\x13\n\x0b\n\x04\x04\0\x02\0\x12\x03\
    \x04\x02\x1e\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03\x04\x02\x0e\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03\x04\x0f\x19\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\
    \x04\x1c\x1d\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x05\x02\x13\n\x0c\n\x05\
    \x04\0\x02\x01\x05\x12\x03\x05\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\
    \x03\x05\t\x0e\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x05\x11\x12\n\x0b\n\
    \x04\x04\0\x02\x02\x12\x03\x06\x02\x1d\n\x0c\n\x05\x04\0\x02\x02\x05\x12\
    \x03\x06\x02\x08\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x06\t\x18\n\x0c\n\
    \x05\x04\0\x02\x02\x03\x12\x03\x06\x1b\x1c\n\x0b\n\x04\x04\0\x02\x03\x12\
    \x03\x07\x02\x1c\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x07\x02\x08\n\x0c\
    \n\x05\x04\0\x02\x03\x01\x12\x03\x07\t\x17\n\x0c\n\x05\x04\0\x02\x03\x03\
    \x12\x03\x07\x1a\x1b\n\x0b\n\x04\x04\0\x02\x04\x12\x03\x08\x02\x1f\n\x0c\
    \n\x05\x04\0\x02\x04\x05\x12\x03\x08\x02\x08\n\x0c\n\x05\x04\0\x02\x04\
    \x01\x12\x03\x08\t\x1a\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\x08\x1d\x1e\
    \n\x0b\n\x04\x04\0\x02\x05\x12\x03\t\x02\x12\n\x0c\n\x05\x04\0\x02\x05\
    \x06\x12\x03\t\x02\x07\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03\t\x08\r\n\
    \x0c\n\x05\x04\0\x02\x05\x03\x12\x03\t\x10\x11\n\x0b\n\x04\x04\0\x02\x06\
    \x12\x03\n\x02\x15\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03\n\x02\n\n\x0c\n\
    \x05\x04\0\x02\x06\x01\x12\x03\n\x0b\x10\n\x0c\n\x05\x04\0\x02\x06\x03\
    \x12\x03\n\x13\x14\n\x0b\n\x04\x04\0\x02\x07\x12\x03\x0b\x02\x14\n\x0c\n\
    \x05\x04\0\x02\x07\x06\x12\x03\x0b\x02\x08\n\x0c\n\x05\x04\0\x02\x07\x01\
    \x12\x03\x0b\t\x0f\n\x0c\n\x05\x04\0\x02\x07\x03\x12\x03\x0b\x12\x13\n\
    \x0b\n\x04\x04\0\x02\x08\x12\x03\x0c\x02\x1e\n\x0c\n\x05\x04\0\x02\x08\
    \x04\x12\x03\x0c\x02\n\n\x0c\n\x05\x04\0\x02\x08\x06\x12\x03\x0c\x0b\x11\
    \n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03\x0c\x12\x19\n\x0c\n\x05\x04\0\x02\
    \x08\x03\x12\x03\x0c\x1c\x1d\n\x0b\n\x04\x04\0\x02\t\x12\x03\r\x02\x16\n\
    \x0c\n\x05\x04\0\x02\t\x05\x12\x03\r\x02\x08\n\x0c\n\x05\x04\0\x02\t\x01\
    \x12\x03\r\t\x10\n\x0c\n\x05\x04\0\x02\t\x03\x12\x03\r\x13\x15\n\n\n\x02\
    \x04\x01\x12\x04\x10\0\x15\x01\n\n\n\x03\x04\x01\x01\x12\x03\x10\x08\x17\
    \n\x0b\n\x04\x04\x01\x02\0\x12\x03\x11\x02\x17\n\x0c\n\x05\x04\x01\x02\0\
    \x05\x12\x03\x11\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x11\t\x12\
    \n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x11\x15\x16\n\x0b\n\x04\x04\x01\
    \x02\x01\x12\x03\x12\x02\x1e\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03\x12\
    \x02\x0e\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x12\x0f\x19\n\x0c\n\x05\
    \x04\x01\x02\x01\x03\x12\x03\x12\x1c\x1d\n\x0b\n\x04\x04\x01\x02\x02\x12\
    \x03\x13\x02\x13\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03\x13\x02\x08\n\
    \x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\x13\t\x0e\n\x0c\n\x05\x04\x01\x02\
    \x02\x03\x12\x03\x13\x11\x12\n\x0b\n\x04\x04\x01\x02\x03\x12\x03\x14\x02\
    \x13\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\x14\x02\x08\n\x0c\n\x05\x04\
    \x01\x02\x03\x01\x12\x03\x14\t\x0e\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\
    \x03\x14\x11\x12\n\n\n\x02\x04\x02\x12\x04\x17\0\x1b\x01\n\n\n\x03\x04\
    \x02\x01\x12\x03\x17\x08\x10\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x18\x02\
    \x14\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x18\x02\x08\n\x0c\n\x05\x04\
    \x02\x02\0\x01\x12\x03\x18\t\x0f\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\
    \x18\x12\x13\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\x19\x02\x16\n\x0c\n\x05\
    \x04\x02\x02\x01\x05\x12\x03\x19\x02\x08\n\x0c\n\x05\x04\x02\x02\x01\x01\
    \x12\x03\x19\t\x11\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x19\x14\x15\n\
    \x0b\n\x04\x04\x02\x02\x02\x12\x03\x1a\x02\x17\n\x0c\n\x05\x04\x02\x02\
    \x02\x05\x12\x03\x1a\x02\x08\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\x1a\
    \t\x12\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\x1a\x15\x16\n\n\n\x02\x05\
    \0\x12\x04\x1d\0(\x01\n\n\n\x03\x05\0\x01\x12\x03\x1d\x05\x11\n\x0b\n\
    \x04\x05\0\x02\0\x12\x03\x1e\x02\x18\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\
    \x1e\x02\x13\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x1e\x16\x17\n\x0b\n\x04\
    \x05\0\x02\x01\x12\x03\x1f\x02\x14\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\
    \x1f\x02\x0f\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x1f\x12\x13\n\x0b\n\
    \x04\x05\0\x02\x02\x12\x03\x20\x02\x17\n\x0c\n\x05\x05\0\x02\x02\x01\x12\
    \x03\x20\x02\x10\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\x20\x13\x16\n\x0b\
    \n\x04\x05\0\x02\x03\x12\x03!\x02\x1f\n\x0c\n\x05\x05\0\x02\x03\x01\x12\
    \x03!\x02\x18\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03!\x1b\x1e\n\x0b\n\x04\
    \x05\0\x02\x04\x12\x03\"\x02\x17\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03\"\
    \x02\x0e\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\"\x11\x16\n\x0b\n\x04\x05\
    \0\x02\x05\x12\x03#\x02\x16\n\x0c\n\x05\x05\0\x02\x05\x01\x12\x03#\x02\r\
    \n\x0c\n\x05\x05\0\x02\x05\x02\x12\x03#\x10\x15\n\x0b\n\x04\x05\0\x02\
    \x06\x12\x03$\x02\x20\n\x0c\n\x05\x05\0\x02\x06\x01\x12\x03$\x02\x17\n\
    \x0c\n\x05\x05\0\x02\x06\x02\x12\x03$\x1a\x1f\n\x0b\n\x04\x05\0\x02\x07\
    \x12\x03%\x02\x17\n\x0c\n\x05\x05\0\x02\x07\x01\x12\x03%\x02\x0e\n\x0c\n\
    \x05\x05\0\x02\x07\x02\x12\x03%\x11\x16\n\x0b\n\x04\x05\0\x02\x08\x12\
    \x03&\x02\x18\n\x0c\n\x05\x05\0\x02\x08\x01\x12\x03&\x02\x0f\n\x0c\n\x05\
    \x05\0\x02\x08\x02\x12\x03&\x12\x17\n\x0b\n\x04\x05\0\x02\t\x12\x03'\x02\
    \x18\n\x0c\n\x05\x05\0\x02\t\x01\x12\x03'\x02\x0f\n\x0c\n\x05\x05\0\x02\
    \t\x02\x12\x03'\x12\x17\n\n\n\x02\x05\x01\x12\x04*\00\x01\n\n\n\x03\x05\
    \x01\x01\x12\x03*\x05\n\n\x0b\n\x04\x05\x01\x02\0\x12\x03+\x02\x0f\n\x0c\
    \n\x05\x05\x01\x02\0\x01\x12\x03+\x02\n\n\x0c\n\x05\x05\x01\x02\0\x02\
    \x12\x03+\r\x0e\n\x0b\n\x04\x05\x01\x02\x01\x12\x03,\x02\x11\n\x0c\n\x05\
    \x05\x01\x02\x01\x01\x12\x03,\x02\x0b\n\x0c\n\x05\x05\x01\x02\x01\x02\
    \x12\x03,\x0e\x10\n\x0b\n\x04\x05\x01\x02\x02\x12\x03-\x02\x10\n\x0c\n\
    \x05\x05\x01\x02\x02\x01\x12\x03-\x02\n\n\x0c\n\x05\x05\x01\x02\x02\x02\
    \x12\x03-\r\x0f\n\x0b\n\x04\x05\x01\x02\x03\x12\x03.\x02\x11\n\x0c\n\x05\
    \x05\x01\x02\x03\x01\x12\x03.\x02\x0b\n\x0c\n\x05\x05\x01\x02\x03\x02\
    \x12\x03.\x0e\x10\n\x0b\n\x04\x05\x01\x02\x04\x12\x03/\x02\x0f\n\x0c\n\
    \x05\x05\x01\x02\x04\x01\x12\x03/\x02\t\n\x0c\n\x05\x05\x01\x02\x04\x02\
    \x12\x03/\x0c\x0e\n\n\n\x02\x05\x02\x12\x042\06\x01\n\n\n\x03\x05\x02\
    \x01\x12\x032\x05\x0b\n\x0b\n\x04\x05\x02\x02\0\x12\x033\x02\x0e\n\x0c\n\
    \x05\x05\x02\x02\0\x01\x12\x033\x02\t\n\x0c\n\x05\x05\x02\x02\0\x02\x12\
    \x033\x0c\r\n\x0b\n\x04\x05\x02\x02\x01\x12\x034\x02\t\n\x0c\n\x05\x05\
    \x02\x02\x01\x01\x12\x034\x02\x04\n\x0c\n\x05\x05\x02\x02\x01\x02\x12\
    \x034\x07\x08\n\x0b\n\x04\x05\x02\x02\x02\x12\x035\x02\r\n\x0c\n\x05\x05\
    \x02\x02\x02\x01\x12\x035\x02\x08\n\x0c\n\x05\x05\x02\x02\x02\x02\x12\
    \x035\x0b\x0c\n\n\n\x02\x05\x03\x12\x048\0;\x01\n\n\n\x03\x05\x03\x01\
    \x12\x038\x05\x0e\n\x0b\n\x04\x05\x03\x02\0\x12\x039\x02\x0e\n\x0c\n\x05\
    \x05\x03\x02\0\x01\x12\x039\x02\t\n\x0c\n\x05\x05\x03\x02\0\x02\x12\x039\
    \x0c\r\n\x0b\n\x04\x05\x03\x02\x01\x12\x03:\x02\x0b\n\x0c\n\x05\x05\x03\
    \x02\x01\x01\x12\x03:\x02\x06\n\x0c\n\x05\x05\x03\x02\x01\x02\x12\x03:\t\
    \n\n\n\n\x02\x04\x03\x12\x04=\0N\x01\n\n\n\x03\x04\x03\x01\x12\x03=\x08\
    \x0e\n\x0b\n\x04\x04\x03\x02\0\x12\x03>\x02\x17\n\x0c\n\x05\x04\x03\x02\
    \0\x05\x12\x03>\x02\x08\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03>\t\x12\n\
    \x0c\n\x05\x04\x03\x02\0\x03\x12\x03>\x15\x16\n\x0b\n\x04\x04\x03\x02\
    \x01\x12\x03?\x02\x16\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03?\x02\x08\n\
    \x0c\n\x05\x04\x03\x02\x01\x01\x12\x03?\t\x11\n\x0c\n\x05\x04\x03\x02\
    \x01\x03\x12\x03?\x14\x15\n\x0b\n\x04\x04\x03\x02\x02\x12\x03@\x02\x15\n\
    \x0c\n\x05\x04\x03\x02\x02\x05\x12\x03@\x02\x08\n\x0c\n\x05\x04\x03\x02\
    \x02\x01\x12\x03@\t\x10\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03@\x13\x14\
    \n\x0b\n\x04\x04\x03\x02\x03\x12\x03A\x02\x15\n\x0c\n\x05\x04\x03\x02\
    \x03\x05\x12\x03A\x02\x08\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03A\t\x10\
    \n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03A\x13\x14\n\x0b\n\x04\x04\x03\
    \x02\x04\x12\x03B\x02\x13\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\x03B\x02\
    \x08\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03B\t\x0e\n\x0c\n\x05\x04\x03\
    \x02\x04\x03\x12\x03B\x11\x12\nX\n\x04\x04\x03\x02\x05\x12\x03D\x02\x14\
    \x1aK\x20Positive\x20number\x20encoded\x20as\x20string.\x20For\x20negati\
    ve\x20transfers\x20use\x20`direction`\n\n\x0c\n\x05\x04\x03\x02\x05\x05\
    \x12\x03D\x02\x08\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x03D\t\x0f\n\x0c\n\
    \x05\x04\x03\x02\x05\x03\x12\x03D\x12\x13\n\x0b\n\x04\x04\x03\x02\x06\
    \x12\x03E\x02\x1d\n\x0c\n\x05\x04\x03\x02\x06\x06\x12\x03E\x02\x0c\n\x0c\
    \n\x05\x04\x03\x02\x06\x01\x12\x03E\r\x18\n\x0c\n\x05\x04\x03\x02\x06\
    \x03\x12\x03E\x1b\x1c\n$\n\x04\x04\x03\x02\x07\x12\x03G\x02\x1a\x1a\x17\
    \x20Direction\x20of\x20transfer\n\n\x0c\n\x05\x04\x03\x02\x07\x06\x12\
    \x03G\x02\x0b\n\x0c\n\x05\x04\x03\x02\x07\x01\x12\x03G\x0c\x15\n\x0c\n\
    \x05\x04\x03\x02\x07\x03\x12\x03G\x18\x19\n\x0c\n\x04\x04\x03\x04\0\x12\
    \x04I\x02M\x03\n\x0c\n\x05\x04\x03\x04\0\x01\x12\x03I\x07\x11\n\r\n\x06\
    \x04\x03\x04\0\x02\0\x12\x03J\x04\x14\n\x0e\n\x07\x04\x03\x04\0\x02\0\
    \x01\x12\x03J\x04\x0f\n\x0e\n\x07\x04\x03\x04\0\x02\0\x02\x12\x03J\x12\
    \x13\n\r\n\x06\x04\x03\x04\0\x02\x01\x12\x03K\x04\x11\n\x0e\n\x07\x04\
    \x03\x04\0\x02\x01\x01\x12\x03K\x04\x0c\n\x0e\n\x07\x04\x03\x04\0\x02\
    \x01\x02\x12\x03K\x0f\x10\n\r\n\x06\x04\x03\x04\0\x02\x02\x12\x03L\x04\
    \x0c\n\x0e\n\x07\x04\x03\x04\0\x02\x02\x01\x12\x03L\x04\x07\n\x0e\n\x07\
    \x04\x03\x04\0\x02\x02\x02\x12\x03L\n\x0b\nP\n\x02\x04\x04\x12\x04R\0V\
    \x01\x1aD\n\x20Cursor\x20used\x20for\x20querying\x20the\x20transaction\
    \x20history\x20from\x20Emerald\x20API\n\n\n\n\x03\x04\x04\x01\x12\x03R\
    \x08\x0e\n\x0b\n\x04\x04\x04\x02\0\x12\x03S\x02\x15\n\x0c\n\x05\x04\x04\
    \x02\0\x05\x12\x03S\x02\x08\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03S\t\x10\
    \n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03S\x13\x14\n\x0b\n\x04\x04\x04\x02\
    \x01\x12\x03T\x02\x13\n\x0c\n\x05\x04\x04\x02\x01\x05\x12\x03T\x02\x08\n\
    \x0c\n\x05\x04\x04\x02\x01\x01\x12\x03T\t\x0e\n\x0c\n\x05\x04\x04\x02\
    \x01\x03\x12\x03T\x11\x12\n\x0b\n\x04\x04\x04\x02\x02\x12\x03U\x02\x10\n\
    \x0c\n\x05\x04\x04\x02\x02\x05\x12\x03U\x02\x08\n\x0c\n\x05\x04\x04\x02\
    \x02\x01\x12\x03U\t\x0b\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\x03U\x0e\x0f\
    b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

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

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