diff --git a/core/lib/da_client/src/lib.rs b/core/lib/da_client/src/lib.rs
index 7e4a2643a259..dce9c0fa8d1b 100644
--- a/core/lib/da_client/src/lib.rs
+++ b/core/lib/da_client/src/lib.rs
@@ -23,6 +23,8 @@ pub trait DataAvailabilityClient: Sync + Send + fmt::Debug {
 
     /// Returns the maximum size of the blob (in bytes) that can be dispatched. None means no limit.
     fn blob_size_limit(&self) -> Option<usize>;
+
+    async fn balance(&self) -> Result<u64, DAError>;
 }
 
 impl Clone for Box<dyn DataAvailabilityClient> {
diff --git a/core/lib/dal/.sqlx/query-2a2083fd04ebd006eb0aa4e0e5f62f3339768a85aaff9a509901e9f42b09097b.json b/core/lib/dal/.sqlx/query-2a2083fd04ebd006eb0aa4e0e5f62f3339768a85aaff9a509901e9f42b09097b.json
deleted file mode 100644
index a713616d582c..000000000000
--- a/core/lib/dal/.sqlx/query-2a2083fd04ebd006eb0aa4e0e5f62f3339768a85aaff9a509901e9f42b09097b.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            SELECT\n                number,\n                pubdata_input\n            FROM\n                l1_batches\n            LEFT JOIN\n                data_availability\n                ON data_availability.l1_batch_number = l1_batches.number\n            WHERE\n                eth_commit_tx_id IS NULL\n                AND number != 0\n                AND data_availability.blob_id IS NULL\n                AND pubdata_input IS NOT NULL\n            ORDER BY\n                number\n            LIMIT\n                $1\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "number",
-        "type_info": "Int8"
-      },
-      {
-        "ordinal": 1,
-        "name": "pubdata_input",
-        "type_info": "Bytea"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Int8"
-      ]
-    },
-    "nullable": [
-      false,
-      true
-    ]
-  },
-  "hash": "2a2083fd04ebd006eb0aa4e0e5f62f3339768a85aaff9a509901e9f42b09097b"
-}
diff --git a/core/lib/dal/.sqlx/query-f2eeb448a856b9e57bcc2a724791fb0ee6299fddc9f89cf70c5b69c7182f0a54.json b/core/lib/dal/.sqlx/query-f2eeb448a856b9e57bcc2a724791fb0ee6299fddc9f89cf70c5b69c7182f0a54.json
new file mode 100644
index 000000000000..bba0056a5ffe
--- /dev/null
+++ b/core/lib/dal/.sqlx/query-f2eeb448a856b9e57bcc2a724791fb0ee6299fddc9f89cf70c5b69c7182f0a54.json
@@ -0,0 +1,34 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT\n                number,\n                pubdata_input,\n                sealed_at\n            FROM\n                l1_batches\n            LEFT JOIN\n                data_availability\n                ON data_availability.l1_batch_number = l1_batches.number\n            WHERE\n                eth_commit_tx_id IS NULL\n                AND number != 0\n                AND data_availability.blob_id IS NULL\n                AND pubdata_input IS NOT NULL\n                AND sealed_at IS NOT NULL\n            ORDER BY\n                number\n            LIMIT\n                $1\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "number",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 1,
+        "name": "pubdata_input",
+        "type_info": "Bytea"
+      },
+      {
+        "ordinal": 2,
+        "name": "sealed_at",
+        "type_info": "Timestamp"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8"
+      ]
+    },
+    "nullable": [
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "f2eeb448a856b9e57bcc2a724791fb0ee6299fddc9f89cf70c5b69c7182f0a54"
+}
diff --git a/core/lib/dal/src/data_availability_dal.rs b/core/lib/dal/src/data_availability_dal.rs
index 41dd7efe2732..8503cc21f283 100644
--- a/core/lib/dal/src/data_availability_dal.rs
+++ b/core/lib/dal/src/data_availability_dal.rs
@@ -184,7 +184,8 @@ impl DataAvailabilityDal<'_, '_> {
             r#"
             SELECT
                 number,
-                pubdata_input
+                pubdata_input,
+                sealed_at
             FROM
                 l1_batches
             LEFT JOIN
@@ -195,6 +196,7 @@ impl DataAvailabilityDal<'_, '_> {
                 AND number != 0
                 AND data_availability.blob_id IS NULL
                 AND pubdata_input IS NOT NULL
+                AND sealed_at IS NOT NULL
             ORDER BY
                 number
             LIMIT
@@ -213,6 +215,7 @@ impl DataAvailabilityDal<'_, '_> {
                 // `unwrap` is safe here because we have a `WHERE` clause that filters out `NULL` values
                 pubdata: row.pubdata_input.unwrap(),
                 l1_batch_number: L1BatchNumber(row.number as u32),
+                sealed_at: row.sealed_at.unwrap().and_utc(),
             })
             .collect())
     }
diff --git a/core/lib/dal/src/models/storage_data_availability.rs b/core/lib/dal/src/models/storage_data_availability.rs
index 2a1b39845e69..cfdbde5ac3a8 100644
--- a/core/lib/dal/src/models/storage_data_availability.rs
+++ b/core/lib/dal/src/models/storage_data_availability.rs
@@ -1,4 +1,4 @@
-use chrono::NaiveDateTime;
+use chrono::{DateTime, NaiveDateTime, Utc};
 use zksync_types::{pubdata_da::DataAvailabilityBlob, L1BatchNumber};
 
 /// Represents a blob in the data availability layer.
@@ -26,4 +26,5 @@ impl From<StorageDABlob> for DataAvailabilityBlob {
 pub struct L1BatchDA {
     pub pubdata: Vec<u8>,
     pub l1_batch_number: L1BatchNumber,
+    pub sealed_at: DateTime<Utc>,
 }
diff --git a/core/node/da_clients/src/avail/client.rs b/core/node/da_clients/src/avail/client.rs
index 115ad77bf44e..4488999112af 100644
--- a/core/node/da_clients/src/avail/client.rs
+++ b/core/node/da_clients/src/avail/client.rs
@@ -231,4 +231,27 @@ impl DataAvailabilityClient for AvailClient {
     fn blob_size_limit(&self) -> Option<usize> {
         Some(RawAvailClient::MAX_BLOB_SIZE)
     }
+
+    async fn balance(&self) -> Result<u64, DAError> {
+        match self.sdk_client.as_ref() {
+            AvailClientMode::Default(client) => {
+                let AvailClientConfig::FullClient(default_config) = &self.config.config else {
+                    unreachable!(); // validated in protobuf config
+                };
+
+                let ws_client = WsClientBuilder::default()
+                    .build(default_config.api_node_url.clone().as_str())
+                    .await
+                    .map_err(to_non_retriable_da_error)?;
+
+                Ok(client
+                    .balance(&ws_client)
+                    .await
+                    .map_err(to_non_retriable_da_error)?)
+            }
+            AvailClientMode::GasRelay(_) => {
+                Ok(0) // TODO: implement balance for gas relay
+            }
+        }
+    }
 }
diff --git a/core/node/da_clients/src/avail/sdk.rs b/core/node/da_clients/src/avail/sdk.rs
index 8f28e797dc9a..f6aac86a962c 100644
--- a/core/node/da_clients/src/avail/sdk.rs
+++ b/core/node/da_clients/src/avail/sdk.rs
@@ -3,6 +3,7 @@
 
 use std::{fmt::Debug, sync::Arc, time};
 
+use anyhow::Context;
 use backon::{ConstantBuilder, Retryable};
 use bytes::Bytes;
 use jsonrpsee::{
@@ -22,7 +23,6 @@ use crate::utils::to_non_retriable_da_error;
 
 const PROTOCOL_VERSION: u8 = 4;
 
-/// An implementation of the `DataAvailabilityClient` trait that interacts with the Avail network.
 #[derive(Debug, Clone)]
 pub(crate) struct RawAvailClient {
     app_id: u32,
@@ -344,6 +344,23 @@ impl RawAvailClient {
 
         Ok(tx_id)
     }
+
+    /// Returns a balance of the address controlled by the `keypair`
+    pub async fn balance(&self, client: &Client) -> anyhow::Result<u64> {
+        let address = to_addr(self.keypair.clone());
+        let resp: serde_json::Value = client
+            .request("state_getStorage", rpc_params![address])
+            .await
+            .context("Error calling state_getStorage RPC")?;
+
+        let balance = resp
+            .as_str()
+            .ok_or_else(|| anyhow::anyhow!("Invalid balance"))?;
+
+        balance
+            .parse()
+            .context("Unable to parse the account balance")
+    }
 }
 
 fn blake2<const N: usize>(data: Vec<u8>) -> [u8; N] {
diff --git a/core/node/da_clients/src/celestia/client.rs b/core/node/da_clients/src/celestia/client.rs
index df0735d4e1e4..9dc91ed141f5 100644
--- a/core/node/da_clients/src/celestia/client.rs
+++ b/core/node/da_clients/src/celestia/client.rs
@@ -97,6 +97,13 @@ impl DataAvailabilityClient for CelestiaClient {
     fn blob_size_limit(&self) -> Option<usize> {
         Some(1973786) // almost 2MB
     }
+
+    async fn balance(&self) -> Result<u64, DAError> {
+        self.client
+            .balance()
+            .await
+            .map_err(to_non_retriable_da_error)
+    }
 }
 
 impl Debug for CelestiaClient {
diff --git a/core/node/da_clients/src/celestia/generated/cosmos.bank.v1beta1.rs b/core/node/da_clients/src/celestia/generated/cosmos.bank.v1beta1.rs
new file mode 100644
index 000000000000..3eb8c536c915
--- /dev/null
+++ b/core/node/da_clients/src/celestia/generated/cosmos.bank.v1beta1.rs
@@ -0,0 +1,1121 @@
+// This file is @generated by prost-build.
+/// Params defines the parameters for the bank module.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Params {
+    #[prost(message, repeated, tag = "1")]
+    pub send_enabled: ::prost::alloc::vec::Vec<SendEnabled>,
+    #[prost(bool, tag = "2")]
+    pub default_send_enabled: bool,
+}
+impl ::prost::Name for Params {
+    const NAME: &'static str = "Params";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Params".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Params".into()
+    }
+}
+/// SendEnabled maps coin denom to a send_enabled status (whether a denom is
+/// sendable).
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SendEnabled {
+    #[prost(string, tag = "1")]
+    pub denom: ::prost::alloc::string::String,
+    #[prost(bool, tag = "2")]
+    pub enabled: bool,
+}
+impl ::prost::Name for SendEnabled {
+    const NAME: &'static str = "SendEnabled";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.SendEnabled".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.SendEnabled".into()
+    }
+}
+/// Input models transaction input.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Input {
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub coins: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for Input {
+    const NAME: &'static str = "Input";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Input".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Input".into()
+    }
+}
+/// Output models transaction outputs.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Output {
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub coins: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for Output {
+    const NAME: &'static str = "Output";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Output".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Output".into()
+    }
+}
+/// Supply represents a struct that passively keeps track of the total supply
+/// amounts in the network.
+/// This message is deprecated now that supply is indexed by denom.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Supply {
+    #[prost(message, repeated, tag = "1")]
+    pub total: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for Supply {
+    const NAME: &'static str = "Supply";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Supply".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Supply".into()
+    }
+}
+/// DenomUnit represents a struct that describes a given
+/// denomination unit of the basic token.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DenomUnit {
+    /// denom represents the string name of the given denom unit (e.g uatom).
+    #[prost(string, tag = "1")]
+    pub denom: ::prost::alloc::string::String,
+    /// exponent represents power of 10 exponent that one must
+    /// raise the base_denom to in order to equal the given DenomUnit's denom
+    /// 1 denom = 10^exponent base_denom
+    /// (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
+    /// exponent = 6, thus: 1 atom = 10^6 uatom).
+    #[prost(uint32, tag = "2")]
+    pub exponent: u32,
+    /// aliases is a list of string aliases for the given denom
+    #[prost(string, repeated, tag = "3")]
+    pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+impl ::prost::Name for DenomUnit {
+    const NAME: &'static str = "DenomUnit";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.DenomUnit".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.DenomUnit".into()
+    }
+}
+/// Metadata represents a struct that describes
+/// a basic token.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Metadata {
+    #[prost(string, tag = "1")]
+    pub description: ::prost::alloc::string::String,
+    /// denom_units represents the list of DenomUnit's for a given coin
+    #[prost(message, repeated, tag = "2")]
+    pub denom_units: ::prost::alloc::vec::Vec<DenomUnit>,
+    /// base represents the base denom (should be the DenomUnit with exponent = 0).
+    #[prost(string, tag = "3")]
+    pub base: ::prost::alloc::string::String,
+    /// display indicates the suggested denom that should be
+    /// displayed in clients.
+    #[prost(string, tag = "4")]
+    pub display: ::prost::alloc::string::String,
+    /// name defines the name of the token (eg: Cosmos Atom)
+    ///
+    /// Since: cosmos-sdk 0.43
+    #[prost(string, tag = "5")]
+    pub name: ::prost::alloc::string::String,
+    /// symbol is the token symbol usually shown on exchanges (eg: ATOM). This can
+    /// be the same as the display.
+    ///
+    /// Since: cosmos-sdk 0.43
+    #[prost(string, tag = "6")]
+    pub symbol: ::prost::alloc::string::String,
+    /// URI to a document (on or off-chain) that contains additional information. Optional.
+    ///
+    /// Since: cosmos-sdk 0.46
+    #[prost(string, tag = "7")]
+    pub uri: ::prost::alloc::string::String,
+    /// URIHash is a sha256 hash of a document pointed by URI. It's used to verify that
+    /// the document didn't change. Optional.
+    ///
+    /// Since: cosmos-sdk 0.46
+    #[prost(string, tag = "8")]
+    pub uri_hash: ::prost::alloc::string::String,
+}
+impl ::prost::Name for Metadata {
+    const NAME: &'static str = "Metadata";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Metadata".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Metadata".into()
+    }
+}
+/// GenesisState defines the bank module's genesis state.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GenesisState {
+    /// params defines all the paramaters of the module.
+    #[prost(message, optional, tag = "1")]
+    pub params: ::core::option::Option<Params>,
+    /// balances is an array containing the balances of all the accounts.
+    #[prost(message, repeated, tag = "2")]
+    pub balances: ::prost::alloc::vec::Vec<Balance>,
+    /// supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+    /// balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+    #[prost(message, repeated, tag = "3")]
+    pub supply: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+    /// denom_metadata defines the metadata of the differents coins.
+    #[prost(message, repeated, tag = "4")]
+    pub denom_metadata: ::prost::alloc::vec::Vec<Metadata>,
+}
+impl ::prost::Name for GenesisState {
+    const NAME: &'static str = "GenesisState";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.GenesisState".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.GenesisState".into()
+    }
+}
+/// Balance defines an account address and balance pair used in the bank module's
+/// genesis state.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Balance {
+    /// address is the address of the balance holder.
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    /// coins defines the different coins this balance holds.
+    #[prost(message, repeated, tag = "2")]
+    pub coins: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for Balance {
+    const NAME: &'static str = "Balance";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.Balance".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.Balance".into()
+    }
+}
+/// QueryBalanceRequest is the request type for the Query/Balance RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryBalanceRequest {
+    /// address is the address to query balances for.
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    /// denom is the coin denom to query balances for.
+    #[prost(string, tag = "2")]
+    pub denom: ::prost::alloc::string::String,
+}
+impl ::prost::Name for QueryBalanceRequest {
+    const NAME: &'static str = "QueryBalanceRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryBalanceRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryBalanceRequest".into()
+    }
+}
+/// QueryBalanceResponse is the response type for the Query/Balance RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryBalanceResponse {
+    /// balance is the balance of the coin.
+    #[prost(message, optional, tag = "1")]
+    pub balance: ::core::option::Option<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for QueryBalanceResponse {
+    const NAME: &'static str = "QueryBalanceResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryBalanceResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryBalanceResponse".into()
+    }
+}
+/// QueryBalanceRequest is the request type for the Query/AllBalances RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryAllBalancesRequest {
+    /// address is the address to query balances for.
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    /// pagination defines an optional pagination for the request.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageRequest,
+    >,
+}
+impl ::prost::Name for QueryAllBalancesRequest {
+    const NAME: &'static str = "QueryAllBalancesRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryAllBalancesRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryAllBalancesRequest".into()
+    }
+}
+/// QueryAllBalancesResponse is the response type for the Query/AllBalances RPC
+/// method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryAllBalancesResponse {
+    /// balances is the balances of all the coins.
+    #[prost(message, repeated, tag = "1")]
+    pub balances: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+    /// pagination defines the pagination in the response.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageResponse,
+    >,
+}
+impl ::prost::Name for QueryAllBalancesResponse {
+    const NAME: &'static str = "QueryAllBalancesResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryAllBalancesResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryAllBalancesResponse".into()
+    }
+}
+/// QuerySpendableBalancesRequest defines the gRPC request structure for querying
+/// an account's spendable balances.
+///
+/// Since: cosmos-sdk 0.46
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySpendableBalancesRequest {
+    /// address is the address to query spendable balances for.
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    /// pagination defines an optional pagination for the request.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageRequest,
+    >,
+}
+impl ::prost::Name for QuerySpendableBalancesRequest {
+    const NAME: &'static str = "QuerySpendableBalancesRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QuerySpendableBalancesRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QuerySpendableBalancesRequest".into()
+    }
+}
+/// QuerySpendableBalancesResponse defines the gRPC response structure for querying
+/// an account's spendable balances.
+///
+/// Since: cosmos-sdk 0.46
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySpendableBalancesResponse {
+    /// balances is the spendable balances of all the coins.
+    #[prost(message, repeated, tag = "1")]
+    pub balances: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+    /// pagination defines the pagination in the response.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageResponse,
+    >,
+}
+impl ::prost::Name for QuerySpendableBalancesResponse {
+    const NAME: &'static str = "QuerySpendableBalancesResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QuerySpendableBalancesResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QuerySpendableBalancesResponse".into()
+    }
+}
+/// QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC
+/// method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalSupplyRequest {
+    /// pagination defines an optional pagination for the request.
+    ///
+    /// Since: cosmos-sdk 0.43
+    #[prost(message, optional, tag = "1")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageRequest,
+    >,
+}
+impl ::prost::Name for QueryTotalSupplyRequest {
+    const NAME: &'static str = "QueryTotalSupplyRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryTotalSupplyRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryTotalSupplyRequest".into()
+    }
+}
+/// QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC
+/// method
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalSupplyResponse {
+    /// supply is the supply of the coins
+    #[prost(message, repeated, tag = "1")]
+    pub supply: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+    /// pagination defines the pagination in the response.
+    ///
+    /// Since: cosmos-sdk 0.43
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageResponse,
+    >,
+}
+impl ::prost::Name for QueryTotalSupplyResponse {
+    const NAME: &'static str = "QueryTotalSupplyResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryTotalSupplyResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryTotalSupplyResponse".into()
+    }
+}
+/// QuerySupplyOfRequest is the request type for the Query/SupplyOf RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySupplyOfRequest {
+    /// denom is the coin denom to query balances for.
+    #[prost(string, tag = "1")]
+    pub denom: ::prost::alloc::string::String,
+}
+impl ::prost::Name for QuerySupplyOfRequest {
+    const NAME: &'static str = "QuerySupplyOfRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QuerySupplyOfRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QuerySupplyOfRequest".into()
+    }
+}
+/// QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySupplyOfResponse {
+    /// amount is the supply of the coin.
+    #[prost(message, optional, tag = "1")]
+    pub amount: ::core::option::Option<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for QuerySupplyOfResponse {
+    const NAME: &'static str = "QuerySupplyOfResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QuerySupplyOfResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QuerySupplyOfResponse".into()
+    }
+}
+/// QueryParamsRequest defines the request type for querying x/bank parameters.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct QueryParamsRequest {}
+impl ::prost::Name for QueryParamsRequest {
+    const NAME: &'static str = "QueryParamsRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryParamsRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryParamsRequest".into()
+    }
+}
+/// QueryParamsResponse defines the response type for querying x/bank parameters.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryParamsResponse {
+    #[prost(message, optional, tag = "1")]
+    pub params: ::core::option::Option<Params>,
+}
+impl ::prost::Name for QueryParamsResponse {
+    const NAME: &'static str = "QueryParamsResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryParamsResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryParamsResponse".into()
+    }
+}
+/// QueryDenomsMetadataRequest is the request type for the Query/DenomsMetadata RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomsMetadataRequest {
+    /// pagination defines an optional pagination for the request.
+    #[prost(message, optional, tag = "1")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageRequest,
+    >,
+}
+impl ::prost::Name for QueryDenomsMetadataRequest {
+    const NAME: &'static str = "QueryDenomsMetadataRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomsMetadataRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomsMetadataRequest".into()
+    }
+}
+/// QueryDenomsMetadataResponse is the response type for the Query/DenomsMetadata RPC
+/// method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomsMetadataResponse {
+    /// metadata provides the client information for all the registered tokens.
+    #[prost(message, repeated, tag = "1")]
+    pub metadatas: ::prost::alloc::vec::Vec<Metadata>,
+    /// pagination defines the pagination in the response.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageResponse,
+    >,
+}
+impl ::prost::Name for QueryDenomsMetadataResponse {
+    const NAME: &'static str = "QueryDenomsMetadataResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomsMetadataResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomsMetadataResponse".into()
+    }
+}
+/// QueryDenomMetadataRequest is the request type for the Query/DenomMetadata RPC method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomMetadataRequest {
+    /// denom is the coin denom to query the metadata for.
+    #[prost(string, tag = "1")]
+    pub denom: ::prost::alloc::string::String,
+}
+impl ::prost::Name for QueryDenomMetadataRequest {
+    const NAME: &'static str = "QueryDenomMetadataRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomMetadataRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomMetadataRequest".into()
+    }
+}
+/// QueryDenomMetadataResponse is the response type for the Query/DenomMetadata RPC
+/// method.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomMetadataResponse {
+    /// metadata describes and provides all the client information for the requested token.
+    #[prost(message, optional, tag = "1")]
+    pub metadata: ::core::option::Option<Metadata>,
+}
+impl ::prost::Name for QueryDenomMetadataResponse {
+    const NAME: &'static str = "QueryDenomMetadataResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomMetadataResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomMetadataResponse".into()
+    }
+}
+/// QueryDenomOwnersRequest defines the request type for the DenomOwners RPC query,
+/// which queries for a paginated set of all account holders of a particular
+/// denomination.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomOwnersRequest {
+    /// denom defines the coin denomination to query all account holders for.
+    #[prost(string, tag = "1")]
+    pub denom: ::prost::alloc::string::String,
+    /// pagination defines an optional pagination for the request.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageRequest,
+    >,
+}
+impl ::prost::Name for QueryDenomOwnersRequest {
+    const NAME: &'static str = "QueryDenomOwnersRequest";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomOwnersRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomOwnersRequest".into()
+    }
+}
+/// DenomOwner defines structure representing an account that owns or holds a
+/// particular denominated token. It contains the account address and account
+/// balance of the denominated token.
+///
+/// Since: cosmos-sdk 0.46
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DenomOwner {
+    /// address defines the address that owns a particular denomination.
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+    /// balance is the balance of the denominated coin for an account.
+    #[prost(message, optional, tag = "2")]
+    pub balance: ::core::option::Option<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for DenomOwner {
+    const NAME: &'static str = "DenomOwner";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.DenomOwner".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.DenomOwner".into()
+    }
+}
+/// QueryDenomOwnersResponse defines the RPC response of a DenomOwners RPC query.
+///
+/// Since: cosmos-sdk 0.46
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryDenomOwnersResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub denom_owners: ::prost::alloc::vec::Vec<DenomOwner>,
+    /// pagination defines the pagination in the response.
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::base::query::PageResponse,
+    >,
+}
+impl ::prost::Name for QueryDenomOwnersResponse {
+    const NAME: &'static str = "QueryDenomOwnersResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.QueryDenomOwnersResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.QueryDenomOwnersResponse".into()
+    }
+}
+/// Generated client implementations.
+pub mod query_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    /// Query defines the gRPC querier service.
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            QueryClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        /// Balance queries the balance of a single coin for a single account.
+        pub async fn balance(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryBalanceRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryBalanceResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/Balance",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "Balance"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// AllBalances queries the balance of all coins for a single account.
+        pub async fn all_balances(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryAllBalancesRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryAllBalancesResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/AllBalances",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "AllBalances"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// SpendableBalances queries the spenable balance of all coins for a single
+        /// account.
+        ///
+        /// Since: cosmos-sdk 0.46
+        pub async fn spendable_balances(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QuerySpendableBalancesRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QuerySpendableBalancesResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/SpendableBalances",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("cosmos.bank.v1beta1.Query", "SpendableBalances"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        /// TotalSupply queries the total supply of all coins.
+        pub async fn total_supply(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryTotalSupplyRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryTotalSupplyResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/TotalSupply",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "TotalSupply"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// SupplyOf queries the supply of a single coin.
+        pub async fn supply_of(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QuerySupplyOfRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QuerySupplyOfResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/SupplyOf",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "SupplyOf"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// Params queries the parameters of x/bank module.
+        pub async fn params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryParamsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/Params",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "Params"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// DenomsMetadata queries the client metadata of a given coin denomination.
+        pub async fn denom_metadata(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomMetadataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryDenomMetadataResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/DenomMetadata",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "DenomMetadata"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// DenomsMetadata queries the client metadata for all registered coin
+        /// denominations.
+        pub async fn denoms_metadata(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomsMetadataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryDenomsMetadataResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/DenomsMetadata",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "DenomsMetadata"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// DenomOwners queries for all account addresses that own a particular token
+        /// denomination.
+        ///
+        /// Since: cosmos-sdk 0.46
+        pub async fn denom_owners(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomOwnersRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryDenomOwnersResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Query/DenomOwners",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Query", "DenomOwners"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// MsgSend represents a message to send coins from one account to another.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgSend {
+    #[prost(string, tag = "1")]
+    pub from_address: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub to_address: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "3")]
+    pub amount: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
+}
+impl ::prost::Name for MsgSend {
+    const NAME: &'static str = "MsgSend";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.MsgSend".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.MsgSend".into()
+    }
+}
+/// MsgSendResponse defines the Msg/Send response type.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct MsgSendResponse {}
+impl ::prost::Name for MsgSendResponse {
+    const NAME: &'static str = "MsgSendResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.MsgSendResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.MsgSendResponse".into()
+    }
+}
+/// MsgMultiSend represents an arbitrary multi-in, multi-out send message.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgMultiSend {
+    #[prost(message, repeated, tag = "1")]
+    pub inputs: ::prost::alloc::vec::Vec<Input>,
+    #[prost(message, repeated, tag = "2")]
+    pub outputs: ::prost::alloc::vec::Vec<Output>,
+}
+impl ::prost::Name for MsgMultiSend {
+    const NAME: &'static str = "MsgMultiSend";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.MsgMultiSend".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.MsgMultiSend".into()
+    }
+}
+/// MsgMultiSendResponse defines the Msg/MultiSend response type.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct MsgMultiSendResponse {}
+impl ::prost::Name for MsgMultiSendResponse {
+    const NAME: &'static str = "MsgMultiSendResponse";
+    const PACKAGE: &'static str = "cosmos.bank.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.bank.v1beta1.MsgMultiSendResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.bank.v1beta1.MsgMultiSendResponse".into()
+    }
+}
+/// Generated client implementations.
+pub mod msg_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    /// Msg defines the bank Msg service.
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            MsgClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        /// Send defines a method for sending coins from one account to another account.
+        pub async fn send(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgSend>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgSendResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Msg/Send",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Msg", "Send"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// MultiSend defines a method for sending coins from some accounts to other accounts.
+        pub async fn multi_send(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgMultiSend>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgMultiSendResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/cosmos.bank.v1beta1.Msg/MultiSend",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("cosmos.bank.v1beta1.Msg", "MultiSend"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
diff --git a/core/node/da_clients/src/celestia/generated/cosmos.base.query.v1beta1.rs b/core/node/da_clients/src/celestia/generated/cosmos.base.query.v1beta1.rs
new file mode 100644
index 000000000000..b236f3026d3f
--- /dev/null
+++ b/core/node/da_clients/src/celestia/generated/cosmos.base.query.v1beta1.rs
@@ -0,0 +1,77 @@
+// This file is @generated by prost-build.
+/// PageRequest is to be embedded in gRPC request messages for efficient
+/// pagination. Ex:
+///
+///   message SomeRequest {
+///           Foo some_parameter = 1;
+///           PageRequest pagination = 2;
+///   }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PageRequest {
+    /// key is a value returned in PageResponse.next_key to begin
+    /// querying the next page most efficiently. Only one of offset or key
+    /// should be set.
+    #[prost(bytes = "vec", tag = "1")]
+    pub key: ::prost::alloc::vec::Vec<u8>,
+    /// offset is a numeric offset that can be used when key is unavailable.
+    /// It is less efficient than using key. Only one of offset or key should
+    /// be set.
+    #[prost(uint64, tag = "2")]
+    pub offset: u64,
+    /// limit is the total number of results to be returned in the result page.
+    /// If left empty it will default to a value to be set by each app.
+    #[prost(uint64, tag = "3")]
+    pub limit: u64,
+    /// count_total is set to true  to indicate that the result set should include
+    /// a count of the total number of items available for pagination in UIs.
+    /// count_total is only respected when offset is used. It is ignored when key
+    /// is set.
+    #[prost(bool, tag = "4")]
+    pub count_total: bool,
+    /// reverse is set to true if results are to be returned in the descending order.
+    ///
+    /// Since: cosmos-sdk 0.43
+    #[prost(bool, tag = "5")]
+    pub reverse: bool,
+}
+impl ::prost::Name for PageRequest {
+    const NAME: &'static str = "PageRequest";
+    const PACKAGE: &'static str = "cosmos.base.query.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.base.query.v1beta1.PageRequest".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.base.query.v1beta1.PageRequest".into()
+    }
+}
+/// PageResponse is to be embedded in gRPC response messages where the
+/// corresponding request message has used PageRequest.
+///
+///   message SomeResponse {
+///           repeated Bar results = 1;
+///           PageResponse page = 2;
+///   }
+#[derive(::serde::Deserialize, ::serde::Serialize)]
+#[serde(default)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PageResponse {
+    /// next_key is the key to be passed to PageRequest.key to
+    /// query the next page most efficiently. It will be empty if
+    /// there are no more results.
+    #[prost(bytes = "vec", tag = "1")]
+    pub next_key: ::prost::alloc::vec::Vec<u8>,
+    /// total is total number of results available if PageRequest.count_total
+    /// was set, its value is undefined otherwise
+    #[prost(uint64, tag = "2")]
+    pub total: u64,
+}
+impl ::prost::Name for PageResponse {
+    const NAME: &'static str = "PageResponse";
+    const PACKAGE: &'static str = "cosmos.base.query.v1beta1";
+    fn full_name() -> ::prost::alloc::string::String {
+        "cosmos.base.query.v1beta1.PageResponse".into()
+    }
+    fn type_url() -> ::prost::alloc::string::String {
+        "/cosmos.base.query.v1beta1.PageResponse".into()
+    }
+}
diff --git a/core/node/da_clients/src/celestia/mod.rs b/core/node/da_clients/src/celestia/mod.rs
index ce648531f282..1baa52466cf2 100644
--- a/core/node/da_clients/src/celestia/mod.rs
+++ b/core/node/da_clients/src/celestia/mod.rs
@@ -24,6 +24,16 @@ pub mod cosmos {
         pub mod v1beta1 {
             include!("generated/cosmos.base.v1beta1.rs");
         }
+
+        pub mod query {
+            include!("generated/cosmos.base.query.v1beta1.rs");
+        }
+    }
+
+    pub mod bank {
+        pub mod v1beta1 {
+            include!("generated/cosmos.bank.v1beta1.rs");
+        }
     }
 
     pub mod tx {
diff --git a/core/node/da_clients/src/celestia/sdk.rs b/core/node/da_clients/src/celestia/sdk.rs
index 5fd9aea79f07..11f10d823f31 100644
--- a/core/node/da_clients/src/celestia/sdk.rs
+++ b/core/node/da_clients/src/celestia/sdk.rs
@@ -20,6 +20,7 @@ use super::{
             query_client::QueryClient as AuthQueryClient, BaseAccount, QueryAccountRequest,
             QueryParamsRequest as QueryAuthParamsRequest,
         },
+        bank::v1beta1::{query_client::QueryClient as BankQueryClient, QueryAllBalancesRequest},
         base::{
             node::{
                 service_client::ServiceClient as MinGasPriceClient,
@@ -377,6 +378,37 @@ impl RawCelestiaClient {
         tracing::debug!(tx_hash = %tx_response.txhash, height, "transaction succeeded");
         Ok(Some(height))
     }
+
+    pub async fn balance(&self) -> anyhow::Result<u64> {
+        let mut auth_query_client = BankQueryClient::new(self.grpc_channel.clone());
+        let resp = auth_query_client
+            .all_balances(QueryAllBalancesRequest {
+                address: self.address.clone(),
+                pagination: None,
+            })
+            .await?;
+
+        let micro_tia_balance = resp
+            .into_inner()
+            .balances
+            .into_iter()
+            .find(|coin| coin.denom == UNITS_SUFFIX)
+            .map_or_else(
+                || {
+                    Err(anyhow::anyhow!(
+                        "no balance found for address: {}",
+                        self.address
+                    ))
+                },
+                |coin| {
+                    coin.amount
+                        .parse::<u64>()
+                        .map_err(|e| anyhow::anyhow!("failed to parse balance: {}", e))
+                },
+            )?;
+
+        Ok(micro_tia_balance)
+    }
 }
 
 /// Returns a `BlobTx` for the given signed tx and blobs.
diff --git a/core/node/da_clients/src/eigen/client.rs b/core/node/da_clients/src/eigen/client.rs
index d977620526aa..f71afc802cd3 100644
--- a/core/node/da_clients/src/eigen/client.rs
+++ b/core/node/da_clients/src/eigen/client.rs
@@ -62,4 +62,8 @@ impl DataAvailabilityClient for EigenClient {
     fn blob_size_limit(&self) -> Option<usize> {
         Some(1920 * 1024) // 2mb - 128kb as a buffer
     }
+
+    async fn balance(&self) -> Result<u64, DAError> {
+        Ok(0) // TODO fetch from API when payments are enabled in Eigen
+    }
 }
diff --git a/core/node/da_clients/src/no_da.rs b/core/node/da_clients/src/no_da.rs
index db0557510ed2..ecfa78ba44de 100644
--- a/core/node/da_clients/src/no_da.rs
+++ b/core/node/da_clients/src/no_da.rs
@@ -25,4 +25,8 @@ impl DataAvailabilityClient for NoDAClient {
     fn blob_size_limit(&self) -> Option<usize> {
         None
     }
+
+    async fn balance(&self) -> Result<u64, DAError> {
+        Ok(0)
+    }
 }
diff --git a/core/node/da_clients/src/object_store.rs b/core/node/da_clients/src/object_store.rs
index 55764e8260e0..8c652e1e2341 100644
--- a/core/node/da_clients/src/object_store.rs
+++ b/core/node/da_clients/src/object_store.rs
@@ -87,6 +87,10 @@ impl DataAvailabilityClient for ObjectStoreDAClient {
     fn blob_size_limit(&self) -> Option<usize> {
         None
     }
+
+    async fn balance(&self) -> Result<u64, DAError> {
+        Ok(0)
+    }
 }
 
 /// Used as a wrapper for the pubdata to be stored in the GCS.
diff --git a/core/node/da_dispatcher/src/da_dispatcher.rs b/core/node/da_dispatcher/src/da_dispatcher.rs
index f59a30b362ee..6a5ed622fd55 100644
--- a/core/node/da_dispatcher/src/da_dispatcher.rs
+++ b/core/node/da_dispatcher/src/da_dispatcher.rs
@@ -103,7 +103,7 @@ impl DataAvailabilityDispatcher {
             .await?;
         drop(conn);
 
-        for batch in batches {
+        for batch in &batches {
             let dispatch_latency = METRICS.blob_dispatch_latency.start();
             let dispatch_response = retry(self.config.max_retries(), batch.l1_batch_number, || {
                 self.client
@@ -135,6 +135,12 @@ impl DataAvailabilityDispatcher {
                 .last_dispatched_l1_batch
                 .set(batch.l1_batch_number.0 as usize);
             METRICS.blob_size.observe(batch.pubdata.len());
+            METRICS.sealed_to_dispatched_lag.observe(
+                Utc::now()
+                    .signed_duration_since(batch.sealed_at)
+                    .to_std()
+                    .context("Time gap between sealed_at and sent_at is out of range")?,
+            );
             tracing::info!(
                 "Dispatched a DA for batch_number: {}, pubdata_size: {}, dispatch_latency: {dispatch_latency_duration:?}",
                 batch.l1_batch_number,
@@ -142,6 +148,27 @@ impl DataAvailabilityDispatcher {
             );
         }
 
+        // We don't need to report this metric every iteration, only once when the balance is changed
+        if !batches.is_empty() {
+            let client_arc = Arc::new(self.client.clone_boxed());
+
+            tokio::spawn(async move {
+                let balance = client_arc
+                    .balance()
+                    .await
+                    .with_context(|| "Unable to retrieve DA operator balance");
+
+                match balance {
+                    Ok(balance) => {
+                        METRICS.operator_balance.set(balance);
+                    }
+                    Err(err) => {
+                        tracing::error!("{err}")
+                    }
+                }
+            });
+        }
+
         Ok(())
     }
 
diff --git a/core/node/da_dispatcher/src/metrics.rs b/core/node/da_dispatcher/src/metrics.rs
index 67ac5ed68222..2e167f2083b3 100644
--- a/core/node/da_dispatcher/src/metrics.rs
+++ b/core/node/da_dispatcher/src/metrics.rs
@@ -4,12 +4,12 @@ use vise::{Buckets, Gauge, Histogram, Metrics, Unit};
 
 /// Buckets for `blob_dispatch_latency` (from 0.1 to 120 seconds).
 const DISPATCH_LATENCIES: Buckets =
-    Buckets::values(&[0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0, 120.0]);
+    Buckets::values(&[0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0, 120.0, 240.0]);
 
 #[derive(Debug, Metrics)]
 #[metrics(prefix = "server_da_dispatcher")]
 pub(super) struct DataAvailabilityDispatcherMetrics {
-    /// Latency of the dispatch of the blob.
+    /// Latency of the dispatch of the blob. Only the communication with DA layer.
     #[metrics(buckets = DISPATCH_LATENCIES, unit = Unit::Seconds)]
     pub blob_dispatch_latency: Histogram<Duration>,
     /// The duration between the moment when the blob is dispatched and the moment when it is included.
@@ -19,7 +19,6 @@ pub(super) struct DataAvailabilityDispatcherMetrics {
     /// Buckets are bytes ranging from 1 KB to 16 MB, which has to satisfy all blob size values.
     #[metrics(buckets = Buckets::exponential(1_024.0..=16.0 * 1_024.0 * 1_024.0, 2.0), unit = Unit::Bytes)]
     pub blob_size: Histogram<usize>,
-
     /// Number of transactions resent by the DA dispatcher.
     #[metrics(buckets = Buckets::linear(0.0..=10.0, 1.0))]
     pub dispatch_call_retries: Histogram<usize>,
@@ -27,6 +26,12 @@ pub(super) struct DataAvailabilityDispatcherMetrics {
     pub last_dispatched_l1_batch: Gauge<usize>,
     /// Last L1 batch that has its inclusion finalized by DA layer.
     pub last_included_l1_batch: Gauge<usize>,
+    /// The delay between the moment batch was sealed and the moment it was dispatched. Includes
+    /// both communication with DA layer and time it spends in the queue on the `da_dispatcher` side.
+    #[metrics(buckets = DISPATCH_LATENCIES, unit = Unit::Seconds)]
+    pub sealed_to_dispatched_lag: Histogram<Duration>,
+    /// The balance of the operator wallet on DA network.
+    pub operator_balance: Gauge<u64>,
 }
 
 #[vise::register]