polyester/gen/buffa/

chain.deposit.v1.rs

// @generated by buffa-codegen. DO NOT EDIT.

/// DepositAddress describes one assigned deposit address for one external chain.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct DepositAddress {
    /// PolyChain-registered source chain id used across deposit flows.
    ///
    /// Field 1: `chain_id`
    #[serde(
        rename = "chainId",
        alias = "chain_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub chain_id: u32,
    /// Assigned external-chain deposit address for the selected account target.
    ///
    /// Field 2: `deposit_address`
    #[serde(
        rename = "depositAddress",
        alias = "deposit_address",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub deposit_address: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for DepositAddress {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("DepositAddress")
            .field("chain_id", &self.chain_id)
            .field("deposit_address", &self.deposit_address)
            .finish()
    }
}
impl DepositAddress {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.DepositAddress";
}
::buffa::impl_default_instance!(DepositAddress);
impl ::buffa::MessageName for DepositAddress {
    const PACKAGE: &'static str = "chain.deposit.v1";
    const NAME: &'static str = "DepositAddress";
    const FULL_NAME: &'static str = "chain.deposit.v1.DepositAddress";
    const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.DepositAddress";
}
impl ::buffa::Message for DepositAddress {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if self.chain_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
        }
        if !self.deposit_address.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.deposit_address) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.chain_id != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.chain_id, buf);
        }
        if !self.deposit_address.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.deposit_address, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.chain_id = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.deposit_address, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.chain_id = 0u32;
        self.deposit_address.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for DepositAddress {
    const PROTO_FQN: &'static str = "chain.deposit.v1.DepositAddress";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for DepositAddress {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __DEPOSIT_ADDRESS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/chain.deposit.v1.DepositAddress",
    to_json: ::buffa::type_registry::any_to_json::<DepositAddress>,
    from_json: ::buffa::type_registry::any_from_json::<DepositAddress>,
    is_wkt: false,
};
/// CreateDepositAddressRequest creates or returns the deposit address for one
/// selected account target and chain.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct CreateDepositAddressRequest {
    /// Optional subaccount public id. When omitted, the authenticated caller's
    /// root account is used as the target account.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub subaccount_id: u64,
    /// PolyChain-registered source chain id to assign the deposit address for.
    ///
    /// Field 2: `chain_id`
    #[serde(
        rename = "chainId",
        alias = "chain_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub chain_id: u32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CreateDepositAddressRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CreateDepositAddressRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("chain_id", &self.chain_id)
            .finish()
    }
}
impl CreateDepositAddressRequest {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressRequest";
}
::buffa::impl_default_instance!(CreateDepositAddressRequest);
impl ::buffa::MessageName for CreateDepositAddressRequest {
    const PACKAGE: &'static str = "chain.deposit.v1";
    const NAME: &'static str = "CreateDepositAddressRequest";
    const FULL_NAME: &'static str = "chain.deposit.v1.CreateDepositAddressRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressRequest";
}
impl ::buffa::Message for CreateDepositAddressRequest {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if self.subaccount_id != 0u64 {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if self.chain_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.subaccount_id != 0u64 {
            ::buffa::types::put_fixed64_field(1u32, self.subaccount_id, buf);
        }
        if self.chain_id != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.chain_id, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed64,
                )?;
                self.subaccount_id = ::buffa::types::decode_fixed64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.chain_id = ::buffa::types::decode_uint32(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = 0u64;
        self.chain_id = 0u32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for CreateDepositAddressRequest {
    const PROTO_FQN: &'static str = "chain.deposit.v1.CreateDepositAddressRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CreateDepositAddressRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __CREATE_DEPOSIT_ADDRESS_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/chain.deposit.v1.CreateDepositAddressRequest",
    to_json: ::buffa::type_registry::any_to_json::<CreateDepositAddressRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CreateDepositAddressRequest>,
    is_wkt: false,
};
/// CreateDepositAddressResponse returns the assigned deposit address for the
/// requested target and chain.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct CreateDepositAddressResponse {
    /// Assigned deposit address for the requested target and chain.
    ///
    /// Field 1: `deposit_address`
    #[serde(
        rename = "depositAddress",
        alias = "deposit_address",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub deposit_address: ::buffa::MessageField<DepositAddress>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CreateDepositAddressResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CreateDepositAddressResponse")
            .field("deposit_address", &self.deposit_address)
            .finish()
    }
}
impl CreateDepositAddressResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressResponse";
}
::buffa::impl_default_instance!(CreateDepositAddressResponse);
impl ::buffa::MessageName for CreateDepositAddressResponse {
    const PACKAGE: &'static str = "chain.deposit.v1";
    const NAME: &'static str = "CreateDepositAddressResponse";
    const FULL_NAME: &'static str = "chain.deposit.v1.CreateDepositAddressResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressResponse";
}
impl ::buffa::Message for CreateDepositAddressResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if self.deposit_address.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.deposit_address.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.deposit_address.is_set() {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            self.deposit_address.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.deposit_address.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.deposit_address = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for CreateDepositAddressResponse {
    const PROTO_FQN: &'static str = "chain.deposit.v1.CreateDepositAddressResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CreateDepositAddressResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __CREATE_DEPOSIT_ADDRESS_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/chain.deposit.v1.CreateDepositAddressResponse",
    to_json: ::buffa::type_registry::any_to_json::<CreateDepositAddressResponse>,
    from_json: ::buffa::type_registry::any_from_json::<CreateDepositAddressResponse>,
    is_wkt: false,
};
/// ListDepositAddressesRequest lists known deposit addresses for one selected
/// account target.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListDepositAddressesRequest {
    /// Optional subaccount public id. When omitted, the authenticated caller's
    /// root account is used as the target account.
    ///
    /// Field 1: `subaccount_id`
    #[serde(
        rename = "subaccountId",
        alias = "subaccount_id",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub subaccount_id: u64,
    /// Optional PolyChain-registered source chain id filter. When omitted, the
    /// response returns all known deposit addresses for the selected target,
    /// ordered by ascending chain id.
    ///
    /// Field 2: `chain_id`
    #[serde(
        rename = "chainId",
        alias = "chain_id",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub chain_id: u32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListDepositAddressesRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListDepositAddressesRequest")
            .field("subaccount_id", &self.subaccount_id)
            .field("chain_id", &self.chain_id)
            .finish()
    }
}
impl ListDepositAddressesRequest {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesRequest";
}
::buffa::impl_default_instance!(ListDepositAddressesRequest);
impl ::buffa::MessageName for ListDepositAddressesRequest {
    const PACKAGE: &'static str = "chain.deposit.v1";
    const NAME: &'static str = "ListDepositAddressesRequest";
    const FULL_NAME: &'static str = "chain.deposit.v1.ListDepositAddressesRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesRequest";
}
impl ::buffa::Message for ListDepositAddressesRequest {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if self.subaccount_id != 0u64 {
            size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
        }
        if self.chain_id != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.subaccount_id != 0u64 {
            ::buffa::types::put_fixed64_field(1u32, self.subaccount_id, buf);
        }
        if self.chain_id != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.chain_id, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed64,
                )?;
                self.subaccount_id = ::buffa::types::decode_fixed64(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.chain_id = ::buffa::types::decode_uint32(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.subaccount_id = 0u64;
        self.chain_id = 0u32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListDepositAddressesRequest {
    const PROTO_FQN: &'static str = "chain.deposit.v1.ListDepositAddressesRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ListDepositAddressesRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __LIST_DEPOSIT_ADDRESSES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/chain.deposit.v1.ListDepositAddressesRequest",
    to_json: ::buffa::type_registry::any_to_json::<ListDepositAddressesRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ListDepositAddressesRequest>,
    is_wkt: false,
};
/// ListDepositAddressesResponse returns the known deposit addresses for the
/// selected target, ordered by ascending chain id.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListDepositAddressesResponse {
    /// Known deposit addresses for the selected target.
    ///
    /// Field 1: `deposit_addresses`
    #[serde(
        rename = "depositAddresses",
        alias = "deposit_addresses",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub deposit_addresses: ::buffa::alloc::vec::Vec<DepositAddress>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListDepositAddressesResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListDepositAddressesResponse")
            .field("deposit_addresses", &self.deposit_addresses)
            .finish()
    }
}
impl ListDepositAddressesResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesResponse";
}
::buffa::impl_default_instance!(ListDepositAddressesResponse);
impl ::buffa::MessageName for ListDepositAddressesResponse {
    const PACKAGE: &'static str = "chain.deposit.v1";
    const NAME: &'static str = "ListDepositAddressesResponse";
    const FULL_NAME: &'static str = "chain.deposit.v1.ListDepositAddressesResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesResponse";
}
impl ::buffa::Message for ListDepositAddressesResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        for v in &self.deposit_addresses {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.deposit_addresses {
            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.deposit_addresses.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.deposit_addresses.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListDepositAddressesResponse {
    const PROTO_FQN: &'static str = "chain.deposit.v1.ListDepositAddressesResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ListDepositAddressesResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __LIST_DEPOSIT_ADDRESSES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/chain.deposit.v1.ListDepositAddressesResponse",
    to_json: ::buffa::type_registry::any_to_json::<ListDepositAddressesResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ListDepositAddressesResponse>,
    is_wkt: false,
};
#[allow(
    non_camel_case_types,
    dead_code,
    unused_imports,
    unused_qualifications,
    clippy::derivable_impls,
    clippy::match_single_binding,
    clippy::uninlined_format_args,
    clippy::doc_lazy_continuation,
    clippy::module_inception
)]
pub mod __buffa {
    #[allow(unused_imports)]
    use super::*;
    pub mod view {
        #[allow(unused_imports)]
        use super::*;
        /// DepositAddress describes one assigned deposit address for one external chain.
        #[derive(Clone, Debug, Default)]
        pub struct DepositAddressView<'a> {
            /// PolyChain-registered source chain id used across deposit flows.
            ///
            /// Field 1: `chain_id`
            pub chain_id: u32,
            /// Assigned external-chain deposit address for the selected account target.
            ///
            /// Field 2: `deposit_address`
            pub deposit_address: &'a str,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for DepositAddressView<'a> {
            type Owned = super::super::DepositAddress;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.chain_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        view.deposit_address = ::buffa::types::borrow_str(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::DepositAddress,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::DepositAddress,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::DepositAddress {
                    chain_id: self.chain_id,
                    deposit_address: self.deposit_address.to_string(),
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for DepositAddressView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                if self.chain_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
                }
                if !self.deposit_address.is_empty() {
                    size
                        += 1u32
                            + ::buffa::types::string_encoded_len(&self.deposit_address)
                                as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.chain_id != 0u32 {
                    ::buffa::types::put_uint32_field(1u32, self.chain_id, buf);
                }
                if !self.deposit_address.is_empty() {
                    ::buffa::types::put_string_field(2u32, &self.deposit_address, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for DepositAddressView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.chain_id) {
                    __map
                        .serialize_entry(
                            "chainId",
                            &::buffa::json_helpers::ProtoJson(&self.chain_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_empty_str(self.deposit_address) {
                    __map.serialize_entry("depositAddress", self.deposit_address)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for DepositAddressView<'a> {
            const PACKAGE: &'static str = "chain.deposit.v1";
            const NAME: &'static str = "DepositAddress";
            const FULL_NAME: &'static str = "chain.deposit.v1.DepositAddress";
            const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.DepositAddress";
        }
        ::buffa::impl_default_view_instance!(DepositAddressView);
        ::buffa::impl_view_reborrow!(DepositAddressView);
        /** Self-contained, `'static` owned view of a `DepositAddress` message.

 Wraps [`::buffa::OwnedView`]`<`[`DepositAddressView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`DepositAddressView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct DepositAddressOwnedView(
            ::buffa::OwnedView<DepositAddressView<'static>>,
        );
        impl DepositAddressOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    DepositAddressOwnedView(::buffa::OwnedView::decode(bytes)?),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    DepositAddressOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::DepositAddress,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    DepositAddressOwnedView(::buffa::OwnedView::from_owned(msg)?),
                )
            }
            /// Borrow the full [`DepositAddressView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &DepositAddressView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::DepositAddress,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// PolyChain-registered source chain id used across deposit flows.
            ///
            /// Field 1: `chain_id`
            #[must_use]
            pub fn chain_id(&self) -> u32 {
                self.0.reborrow().chain_id
            }
            /// Assigned external-chain deposit address for the selected account target.
            ///
            /// Field 2: `deposit_address`
            #[must_use]
            pub fn deposit_address(&self) -> &'_ str {
                self.0.reborrow().deposit_address
            }
        }
        impl ::core::convert::From<::buffa::OwnedView<DepositAddressView<'static>>>
        for DepositAddressOwnedView {
            fn from(inner: ::buffa::OwnedView<DepositAddressView<'static>>) -> Self {
                DepositAddressOwnedView(inner)
            }
        }
        impl ::core::convert::From<DepositAddressOwnedView>
        for ::buffa::OwnedView<DepositAddressView<'static>> {
            fn from(wrapper: DepositAddressOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<::buffa::OwnedView<DepositAddressView<'static>>>
        for DepositAddressOwnedView {
            fn as_ref(&self) -> &::buffa::OwnedView<DepositAddressView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::DepositAddress {
            type View<'a> = DepositAddressView<'a>;
            type ViewHandle = DepositAddressOwnedView;
        }
        impl ::serde::Serialize for DepositAddressOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// CreateDepositAddressRequest creates or returns the deposit address for one
        /// selected account target and chain.
        #[derive(Clone, Debug, Default)]
        pub struct CreateDepositAddressRequestView<'a> {
            /// Optional subaccount public id. When omitted, the authenticated caller's
            /// root account is used as the target account.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: u64,
            /// PolyChain-registered source chain id to assign the deposit address for.
            ///
            /// Field 2: `chain_id`
            pub chain_id: u32,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for CreateDepositAddressRequestView<'a> {
            type Owned = super::super::CreateDepositAddressRequest;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed64,
                        )?;
                        view.subaccount_id = ::buffa::types::decode_fixed64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.chain_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressRequest,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::CreateDepositAddressRequest {
                    subaccount_id: self.subaccount_id,
                    chain_id: self.chain_id,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for CreateDepositAddressRequestView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                if self.subaccount_id != 0u64 {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if self.chain_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.subaccount_id != 0u64 {
                    ::buffa::types::put_fixed64_field(1u32, self.subaccount_id, buf);
                }
                if self.chain_id != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.chain_id, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for CreateDepositAddressRequestView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.subaccount_id) {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&self.subaccount_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.chain_id) {
                    __map
                        .serialize_entry(
                            "chainId",
                            &::buffa::json_helpers::ProtoJson(&self.chain_id),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for CreateDepositAddressRequestView<'a> {
            const PACKAGE: &'static str = "chain.deposit.v1";
            const NAME: &'static str = "CreateDepositAddressRequest";
            const FULL_NAME: &'static str = "chain.deposit.v1.CreateDepositAddressRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressRequest";
        }
        ::buffa::impl_default_view_instance!(CreateDepositAddressRequestView);
        ::buffa::impl_view_reborrow!(CreateDepositAddressRequestView);
        /** Self-contained, `'static` owned view of a `CreateDepositAddressRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`CreateDepositAddressRequestView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CreateDepositAddressRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct CreateDepositAddressRequestOwnedView(
            ::buffa::OwnedView<CreateDepositAddressRequestView<'static>>,
        );
        impl CreateDepositAddressRequestOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressRequestOwnedView(
                        ::buffa::OwnedView::decode(bytes)?,
                    ),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressRequestOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::CreateDepositAddressRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`CreateDepositAddressRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &CreateDepositAddressRequestView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressRequest,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// Optional subaccount public id. When omitted, the authenticated caller's
            /// root account is used as the target account.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> u64 {
                self.0.reborrow().subaccount_id
            }
            /// PolyChain-registered source chain id to assign the deposit address for.
            ///
            /// Field 2: `chain_id`
            #[must_use]
            pub fn chain_id(&self) -> u32 {
                self.0.reborrow().chain_id
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<CreateDepositAddressRequestView<'static>>,
        > for CreateDepositAddressRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<CreateDepositAddressRequestView<'static>>,
            ) -> Self {
                CreateDepositAddressRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<CreateDepositAddressRequestOwnedView>
        for ::buffa::OwnedView<CreateDepositAddressRequestView<'static>> {
            fn from(wrapper: CreateDepositAddressRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<CreateDepositAddressRequestView<'static>>,
        > for CreateDepositAddressRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<CreateDepositAddressRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::CreateDepositAddressRequest {
            type View<'a> = CreateDepositAddressRequestView<'a>;
            type ViewHandle = CreateDepositAddressRequestOwnedView;
        }
        impl ::serde::Serialize for CreateDepositAddressRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// CreateDepositAddressResponse returns the assigned deposit address for the
        /// requested target and chain.
        #[derive(Clone, Debug, Default)]
        pub struct CreateDepositAddressResponseView<'a> {
            /// Assigned deposit address for the requested target and chain.
            ///
            /// Field 1: `deposit_address`
            pub deposit_address: ::buffa::MessageFieldView<
                super::super::__buffa::view::DepositAddressView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for CreateDepositAddressResponseView<'a> {
            type Owned = super::super::CreateDepositAddressResponse;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        match view.deposit_address.as_mut() {
                            Some(existing) => {
                                ::buffa::MessageView::merge_into_view(
                                    existing,
                                    sub,
                                    __sub_ctx,
                                )?
                            }
                            None => {
                                view.deposit_address = ::buffa::MessageFieldView::set(
                                    <super::super::__buffa::view::DepositAddressView as ::buffa::MessageView>::decode_view_ctx(
                                        sub,
                                        __sub_ctx,
                                    )?,
                                );
                            }
                        }
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressResponse,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::CreateDepositAddressResponse {
                    deposit_address: match self.deposit_address.as_option() {
                        Some(v) => {
                            ::buffa::MessageField::<
                                super::super::DepositAddress,
                            >::some(v.to_owned_from_source(__buffa_src)?)
                        }
                        None => ::buffa::MessageField::none(),
                    },
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for CreateDepositAddressResponseView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                if self.deposit_address.is_set() {
                    let __slot = __cache.reserve();
                    let inner_size = self.deposit_address.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.deposit_address.is_set() {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    self.deposit_address.write_to(__cache, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for CreateDepositAddressResponseView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                {
                    if let ::core::option::Option::Some(__v) = self
                        .deposit_address
                        .as_option()
                    {
                        __map.serialize_entry("depositAddress", __v)?;
                    }
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for CreateDepositAddressResponseView<'a> {
            const PACKAGE: &'static str = "chain.deposit.v1";
            const NAME: &'static str = "CreateDepositAddressResponse";
            const FULL_NAME: &'static str = "chain.deposit.v1.CreateDepositAddressResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.CreateDepositAddressResponse";
        }
        ::buffa::impl_default_view_instance!(CreateDepositAddressResponseView);
        ::buffa::impl_view_reborrow!(CreateDepositAddressResponseView);
        /** Self-contained, `'static` owned view of a `CreateDepositAddressResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`CreateDepositAddressResponseView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CreateDepositAddressResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct CreateDepositAddressResponseOwnedView(
            ::buffa::OwnedView<CreateDepositAddressResponseView<'static>>,
        );
        impl CreateDepositAddressResponseOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressResponseOwnedView(
                        ::buffa::OwnedView::decode(bytes)?,
                    ),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressResponseOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::CreateDepositAddressResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    CreateDepositAddressResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`CreateDepositAddressResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &CreateDepositAddressResponseView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::CreateDepositAddressResponse,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// Assigned deposit address for the requested target and chain.
            ///
            /// Field 1: `deposit_address`
            #[must_use]
            pub fn deposit_address(
                &self,
            ) -> &::buffa::MessageFieldView<
                super::super::__buffa::view::DepositAddressView<'_>,
            > {
                &self.0.reborrow().deposit_address
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<CreateDepositAddressResponseView<'static>>,
        > for CreateDepositAddressResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<CreateDepositAddressResponseView<'static>>,
            ) -> Self {
                CreateDepositAddressResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<CreateDepositAddressResponseOwnedView>
        for ::buffa::OwnedView<CreateDepositAddressResponseView<'static>> {
            fn from(wrapper: CreateDepositAddressResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<CreateDepositAddressResponseView<'static>>,
        > for CreateDepositAddressResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<CreateDepositAddressResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::CreateDepositAddressResponse {
            type View<'a> = CreateDepositAddressResponseView<'a>;
            type ViewHandle = CreateDepositAddressResponseOwnedView;
        }
        impl ::serde::Serialize for CreateDepositAddressResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ListDepositAddressesRequest lists known deposit addresses for one selected
        /// account target.
        #[derive(Clone, Debug, Default)]
        pub struct ListDepositAddressesRequestView<'a> {
            /// Optional subaccount public id. When omitted, the authenticated caller's
            /// root account is used as the target account.
            ///
            /// Field 1: `subaccount_id`
            pub subaccount_id: u64,
            /// Optional PolyChain-registered source chain id filter. When omitted, the
            /// response returns all known deposit addresses for the selected target,
            /// ordered by ascending chain id.
            ///
            /// Field 2: `chain_id`
            pub chain_id: u32,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListDepositAddressesRequestView<'a> {
            type Owned = super::super::ListDepositAddressesRequest;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Fixed64,
                        )?;
                        view.subaccount_id = ::buffa::types::decode_fixed64(&mut cur)?;
                    }
                    2u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::Varint,
                        )?;
                        view.chain_id = ::buffa::types::decode_uint32(&mut cur)?;
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesRequest,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesRequest,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListDepositAddressesRequest {
                    subaccount_id: self.subaccount_id,
                    chain_id: self.chain_id,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListDepositAddressesRequestView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                if self.subaccount_id != 0u64 {
                    size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
                }
                if self.chain_id != 0u32 {
                    size
                        += 1u32
                            + ::buffa::types::uint32_encoded_len(self.chain_id) as u32;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                _cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                if self.subaccount_id != 0u64 {
                    ::buffa::types::put_fixed64_field(1u32, self.subaccount_id, buf);
                }
                if self.chain_id != 0u32 {
                    ::buffa::types::put_uint32_field(2u32, self.chain_id, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for ListDepositAddressesRequestView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !::buffa::json_helpers::skip_if::is_zero_u64(&self.subaccount_id) {
                    __map
                        .serialize_entry(
                            "subaccountId",
                            &::buffa::json_helpers::ProtoJson(&self.subaccount_id),
                        )?;
                }
                if !::buffa::json_helpers::skip_if::is_zero_u32(&self.chain_id) {
                    __map
                        .serialize_entry(
                            "chainId",
                            &::buffa::json_helpers::ProtoJson(&self.chain_id),
                        )?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListDepositAddressesRequestView<'a> {
            const PACKAGE: &'static str = "chain.deposit.v1";
            const NAME: &'static str = "ListDepositAddressesRequest";
            const FULL_NAME: &'static str = "chain.deposit.v1.ListDepositAddressesRequest";
            const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesRequest";
        }
        ::buffa::impl_default_view_instance!(ListDepositAddressesRequestView);
        ::buffa::impl_view_reborrow!(ListDepositAddressesRequestView);
        /** Self-contained, `'static` owned view of a `ListDepositAddressesRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListDepositAddressesRequestView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`ListDepositAddressesRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListDepositAddressesRequestOwnedView(
            ::buffa::OwnedView<ListDepositAddressesRequestView<'static>>,
        );
        impl ListDepositAddressesRequestOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesRequestOwnedView(
                        ::buffa::OwnedView::decode(bytes)?,
                    ),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesRequestOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::ListDepositAddressesRequest,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesRequestOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`ListDepositAddressesRequestView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListDepositAddressesRequestView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesRequest,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// Optional subaccount public id. When omitted, the authenticated caller's
            /// root account is used as the target account.
            ///
            /// Field 1: `subaccount_id`
            #[must_use]
            pub fn subaccount_id(&self) -> u64 {
                self.0.reborrow().subaccount_id
            }
            /// Optional PolyChain-registered source chain id filter. When omitted, the
            /// response returns all known deposit addresses for the selected target,
            /// ordered by ascending chain id.
            ///
            /// Field 2: `chain_id`
            #[must_use]
            pub fn chain_id(&self) -> u32 {
                self.0.reborrow().chain_id
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<ListDepositAddressesRequestView<'static>>,
        > for ListDepositAddressesRequestOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListDepositAddressesRequestView<'static>>,
            ) -> Self {
                ListDepositAddressesRequestOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListDepositAddressesRequestOwnedView>
        for ::buffa::OwnedView<ListDepositAddressesRequestView<'static>> {
            fn from(wrapper: ListDepositAddressesRequestOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListDepositAddressesRequestView<'static>>,
        > for ListDepositAddressesRequestOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<ListDepositAddressesRequestView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListDepositAddressesRequest {
            type View<'a> = ListDepositAddressesRequestView<'a>;
            type ViewHandle = ListDepositAddressesRequestOwnedView;
        }
        impl ::serde::Serialize for ListDepositAddressesRequestOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
        /// ListDepositAddressesResponse returns the known deposit addresses for the
        /// selected target, ordered by ascending chain id.
        #[derive(Clone, Debug, Default)]
        pub struct ListDepositAddressesResponseView<'a> {
            /// Known deposit addresses for the selected target.
            ///
            /// Field 1: `deposit_addresses`
            pub deposit_addresses: ::buffa::RepeatedView<
                'a,
                super::super::__buffa::view::DepositAddressView<'a>,
            >,
            pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
        }
        impl<'a> ::buffa::MessageView<'a> for ListDepositAddressesResponseView<'a> {
            type Owned = super::super::ListDepositAddressesResponse;
            fn decode_view(
                buf: &'a [u8],
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                let __limit = ::core::cell::Cell::new(
                    ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
                );
                <Self as ::buffa::MessageView>::decode_view_ctx(
                    buf,
                    ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
                )
            }
            fn decode_view_with_ctx(
                buf: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
            }
            fn merge_view_field(
                &mut self,
                tag: ::buffa::encoding::Tag,
                cur: &'a [u8],
                before_tag: &'a [u8],
                ctx: ::buffa::DecodeContext<'_>,
            ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
                let _ = ctx;
                #[allow(unused_variables)]
                let view = self;
                let mut cur = cur;
                match tag.field_number() {
                    1u32 => {
                        ::buffa::encoding::check_wire_type(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )?;
                        let __sub_ctx = ctx.descend()?;
                        let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                        view.deposit_addresses
                            .push(
                                <super::super::__buffa::view::DepositAddressView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                    }
                    _ => {
                        ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                        let span_len = before_tag.len() - cur.len();
                        view.__buffa_unknown_fields
                            .push_record(before_tag, span_len, ctx)?;
                    }
                }
                ::core::result::Result::Ok(cur)
            }
            fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesResponse,
                ::buffa::DecodeError,
            > {
                self.to_owned_from_source(None)
            }
            #[allow(clippy::useless_conversion, clippy::needless_update)]
            fn to_owned_from_source(
                &self,
                __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesResponse,
                ::buffa::DecodeError,
            > {
                #[allow(unused_imports)]
                use ::buffa::alloc::string::ToString as _;
                let _ = __buffa_src;
                ::core::result::Result::Ok(super::super::ListDepositAddressesResponse {
                    deposit_addresses: self
                        .deposit_addresses
                        .iter()
                        .map(|v| v.to_owned_from_source(__buffa_src))
                        .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
                    __buffa_unknown_fields: self
                        .__buffa_unknown_fields
                        .to_owned()?
                        .into(),
                    ..::core::default::Default::default()
                })
            }
        }
        impl<'a> ::buffa::ViewEncode<'a> for ListDepositAddressesResponseView<'a> {
            #[allow(clippy::needless_borrow, clippy::let_and_return)]
            fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                let mut size = 0u32;
                for v in &self.deposit_addresses {
                    let __slot = __cache.reserve();
                    let inner_size = v.compute_size(__cache);
                    __cache.set(__slot, inner_size);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                            + inner_size;
                }
                size += self.__buffa_unknown_fields.encoded_len() as u32;
                size
            }
            #[allow(clippy::needless_borrow)]
            fn write_to(
                &self,
                __cache: &mut ::buffa::SizeCache,
                buf: &mut impl ::buffa::bytes::BufMut,
            ) {
                #[allow(unused_imports)]
                use ::buffa::Enumeration as _;
                for v in &self.deposit_addresses {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        __cache.consume_next(),
                        buf,
                    );
                    v.write_to(__cache, buf);
                }
                self.__buffa_unknown_fields.write_to(buf);
            }
        }
        /// Serializes this view as protobuf JSON.
        ///
        /// Implicit-presence fields with default values are omitted, `required`
        /// fields are always emitted, explicit-presence (`optional`) fields are
        /// emitted only when set, bytes fields are base64-encoded, and enum
        /// values are their proto name strings.
        ///
        /// This impl uses `serialize_map(None)` because the number of emitted
        /// fields depends on default-omission rules; serializers that require
        /// known map lengths (e.g. `bincode`) will return a runtime error.
        /// Use the owned message type for those formats.
        impl<'__a> ::serde::Serialize for ListDepositAddressesResponseView<'__a> {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                use ::serde::ser::SerializeMap as _;
                let mut __map = __s.serialize_map(::core::option::Option::None)?;
                if !self.deposit_addresses.is_empty() {
                    __map.serialize_entry("depositAddresses", &*self.deposit_addresses)?;
                }
                __map.end()
            }
        }
        impl<'a> ::buffa::MessageName for ListDepositAddressesResponseView<'a> {
            const PACKAGE: &'static str = "chain.deposit.v1";
            const NAME: &'static str = "ListDepositAddressesResponse";
            const FULL_NAME: &'static str = "chain.deposit.v1.ListDepositAddressesResponse";
            const TYPE_URL: &'static str = "type.googleapis.com/chain.deposit.v1.ListDepositAddressesResponse";
        }
        ::buffa::impl_default_view_instance!(ListDepositAddressesResponseView);
        ::buffa::impl_view_reborrow!(ListDepositAddressesResponseView);
        /** Self-contained, `'static` owned view of a `ListDepositAddressesResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListDepositAddressesResponseView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`ListDepositAddressesResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
        #[derive(Clone, Debug)]
        pub struct ListDepositAddressesResponseOwnedView(
            ::buffa::OwnedView<ListDepositAddressesResponseView<'static>>,
        );
        impl ListDepositAddressesResponseOwnedView {
            /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
            ///
            /// The view borrows directly from the buffer's data; the buffer is
            /// retained inside the returned handle.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
            /// protobuf data.
            pub fn decode(
                bytes: ::buffa::bytes::Bytes,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesResponseOwnedView(
                        ::buffa::OwnedView::decode(bytes)?,
                    ),
                )
            }
            /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
            /// max message size).
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
            /// exceeds the configured limits.
            pub fn decode_with_options(
                bytes: ::buffa::bytes::Bytes,
                opts: &::buffa::DecodeOptions,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesResponseOwnedView(
                        ::buffa::OwnedView::decode_with_options(bytes, opts)?,
                    ),
                )
            }
            /// Build from an owned message via an encode → decode round-trip.
            ///
            /// # Errors
            ///
            /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
            /// somehow invalid (should not happen for well-formed messages).
            pub fn from_owned(
                msg: &super::super::ListDepositAddressesResponse,
            ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
                ::core::result::Result::Ok(
                    ListDepositAddressesResponseOwnedView(
                        ::buffa::OwnedView::from_owned(msg)?,
                    ),
                )
            }
            /// Borrow the full [`ListDepositAddressesResponseView`] with its lifetime tied to `&self`.
            #[must_use]
            pub fn view(&self) -> &ListDepositAddressesResponseView<'_> {
                self.0.reborrow()
            }
            /// Convert to the owned message type.
            ///
            /// # Errors
            ///
            /// Returns an error if re-materializing preserved unknown fields
            /// fails (e.g. the unknown-field limit is exceeded).
            pub fn to_owned_message(
                &self,
            ) -> ::core::result::Result<
                super::super::ListDepositAddressesResponse,
                ::buffa::DecodeError,
            > {
                self.0.to_owned_message()
            }
            /// The underlying bytes buffer.
            #[must_use]
            pub fn bytes(&self) -> &::buffa::bytes::Bytes {
                self.0.bytes()
            }
            /// Consume the handle, returning the underlying bytes buffer.
            #[must_use]
            pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
                self.0.into_bytes()
            }
            /// Known deposit addresses for the selected target.
            ///
            /// Field 1: `deposit_addresses`
            #[must_use]
            pub fn deposit_addresses(
                &self,
            ) -> &::buffa::RepeatedView<
                '_,
                super::super::__buffa::view::DepositAddressView<'_>,
            > {
                &self.0.reborrow().deposit_addresses
            }
        }
        impl ::core::convert::From<
            ::buffa::OwnedView<ListDepositAddressesResponseView<'static>>,
        > for ListDepositAddressesResponseOwnedView {
            fn from(
                inner: ::buffa::OwnedView<ListDepositAddressesResponseView<'static>>,
            ) -> Self {
                ListDepositAddressesResponseOwnedView(inner)
            }
        }
        impl ::core::convert::From<ListDepositAddressesResponseOwnedView>
        for ::buffa::OwnedView<ListDepositAddressesResponseView<'static>> {
            fn from(wrapper: ListDepositAddressesResponseOwnedView) -> Self {
                wrapper.0
            }
        }
        impl ::core::convert::AsRef<
            ::buffa::OwnedView<ListDepositAddressesResponseView<'static>>,
        > for ListDepositAddressesResponseOwnedView {
            fn as_ref(
                &self,
            ) -> &::buffa::OwnedView<ListDepositAddressesResponseView<'static>> {
                &self.0
            }
        }
        impl ::buffa::HasMessageView for super::super::ListDepositAddressesResponse {
            type View<'a> = ListDepositAddressesResponseView<'a>;
            type ViewHandle = ListDepositAddressesResponseOwnedView;
        }
        impl ::serde::Serialize for ListDepositAddressesResponseOwnedView {
            fn serialize<__S: ::serde::Serializer>(
                &self,
                __s: __S,
            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                ::serde::Serialize::serialize(&self.0, __s)
            }
        }
    }
    /// Register this package's `Any` type entries and extension entries.
    pub fn register_types(reg: &mut ::buffa::type_registry::TypeRegistry) {
        reg.register_json_any(super::__DEPOSIT_ADDRESS_JSON_ANY);
        reg.register_json_any(super::__CREATE_DEPOSIT_ADDRESS_REQUEST_JSON_ANY);
        reg.register_json_any(super::__CREATE_DEPOSIT_ADDRESS_RESPONSE_JSON_ANY);
        reg.register_json_any(super::__LIST_DEPOSIT_ADDRESSES_REQUEST_JSON_ANY);
        reg.register_json_any(super::__LIST_DEPOSIT_ADDRESSES_RESPONSE_JSON_ANY);
    }
}
#[doc(inline)]
pub use self::__buffa::view::DepositAddressView;
#[doc(inline)]
pub use self::__buffa::view::DepositAddressOwnedView;
#[doc(inline)]
pub use self::__buffa::view::CreateDepositAddressRequestView;
#[doc(inline)]
pub use self::__buffa::view::CreateDepositAddressRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::CreateDepositAddressResponseView;
#[doc(inline)]
pub use self::__buffa::view::CreateDepositAddressResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListDepositAddressesRequestView;
#[doc(inline)]
pub use self::__buffa::view::ListDepositAddressesRequestOwnedView;
#[doc(inline)]
pub use self::__buffa::view::ListDepositAddressesResponseView;
#[doc(inline)]
pub use self::__buffa::view::ListDepositAddressesResponseOwnedView;
#[doc(inline)]
pub use self::__buffa::register_types;