feat(rpc): add z_getstandardfee RPC returning the ZIP-317 marginal fee

Add a parameterless `z_getstandardfee` JSON-RPC method that returns the
recommended standard fee per logical action. This is the static interface
placeholder (version 0) from the draft ZIP "Dynamic Fee Estimation via
z_getstandardfee": it returns the current ZIP-317 marginal fee (5000
zatoshis) so wallets can integrate against a stable method signature now,
while a future change replaces the value with a dynamic estimate and
increments the version field without altering the result shape.

The result object is { standard_fee, version, height }, matching the draft
ZIP's specification.

Author: aphelionz

CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org).
 
 ## [Unreleased]
 
+### Added
+
+- Added the `z_getstandardfee` RPC, a parameterless method returning the
+  recommended standard fee per logical action (the ZIP-317 marginal fee, 5000
+  zatoshis) with a `version` field for future dynamic fee estimation
+  ([#10717](https://github.com/ZcashFoundation/zebra/pull/10717))
+
 ## [Zebra 5.1.1](https://github.com/ZcashFoundation/zebra/releases/tag/v5.1.1) - 2026-06-11
 
 This release reduces Zebra's end-of-support window ahead of the NU7 network upgrade

zebra-rpc/src/methods.rs

@@ -133,6 +133,7 @@ use types::{
     transaction::TransactionObject,
     unified_address::ZListUnifiedReceiversResponse,
     validate_address::ValidateAddressResponse,
+    z_getstandardfee::ZGetStandardFeeResponse,
     z_validate_address::ZValidateAddressResponse,
 };
 
@@ -647,6 +648,16 @@ pub trait Rpc {
     #[method(name = "z_validateaddress")]
     async fn z_validate_address(&self, address: String) -> Result<ZValidateAddressResponse>;
 
+    /// Returns the recommended standard fee per logical action, in zatoshis.
+    ///
+    /// Currently returns a static fee with `version` 0; this will be replaced by
+    /// a dynamic estimate without changing the parameters or result shape.
+    ///
+    /// method: post
+    /// tags: fees
+    #[method(name = "z_getstandardfee")]
+    async fn z_getstandardfee(&self) -> Result<ZGetStandardFeeResponse>;
+
     /// Returns the block subsidy reward of the block at `height`, taking into account the mining slow start.
     /// Returns an error if `height` is less than the height of the first halving for the current network.
     ///
@@ -2792,6 +2803,23 @@ where
         z_validate_address(network, raw_address)
     }
 
+    async fn z_getstandardfee(&self) -> Result<ZGetStandardFeeResponse> {
+        // The current standard fee: 5000 zatoshis per logical action.
+        const MARGINAL_FEE_ZATOSHIS: u64 = 5000;
+        const VERSION: u32 = 0;
+
+        let height = self
+            .latest_chain_tip
+            .best_tip_height()
+            .ok_or_misc_error("no chain tip available, wait until a block is committed")?;
+
+        Ok(ZGetStandardFeeResponse::new(
+            MARGINAL_FEE_ZATOSHIS,
+            VERSION,
+            height.0,
+        ))
+    }
+
     async fn get_block_subsidy(&self, height: Option<u32>) -> Result<GetBlockSubsidyResponse> {
         let net = self.network.clone();
 

zebra-rpc/src/methods/tests/vectors.rs

@@ -3190,3 +3190,43 @@ async fn rpc_gettxout() {
     let rpc_tx_queue_task_result = rpc_tx_queue.now_or_never();
     assert!(rpc_tx_queue_task_result.is_none());
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn rpc_z_getstandardfee() {
+    let _init_guard = zebra_test::init();
+
+    let mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
+    let state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
+    let read_state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
+
+    let (tip, tip_sender) = MockChainTip::new();
+    tip_sender.send_best_tip_height(Height(2_750_000));
+
+    let (_tx, rx) = tokio::sync::watch::channel(None);
+    let (rpc, _rpc_tx_queue) = RpcImpl::new(
+        Mainnet,
+        Default::default(),
+        Default::default(),
+        "0.0.1",
+        "RPC test",
+        Buffer::new(mempool.clone(), 1),
+        Buffer::new(state.clone(), 1),
+        Buffer::new(read_state.clone(), 1),
+        MockService::build().for_unit_tests(),
+        MockSyncStatus::default(),
+        tip,
+        MockAddressBookPeers::default(),
+        rx,
+        None,
+    );
+
+    let response = rpc
+        .z_getstandardfee()
+        .await
+        .expect("z_getstandardfee should succeed with a chain tip");
+
+    // Static v0 placeholder: the ZIP-317 marginal fee, version 0, and the tip height.
+    assert_eq!(response.standard_fee(), 5000);
+    assert_eq!(response.version(), 0);
+    assert_eq!(response.height(), 2_750_000);
+}

zebra-rpc/src/methods/types.rs

@@ -14,5 +14,6 @@ pub mod subsidy;
 pub mod transaction;
 pub mod unified_address;
 pub mod validate_address;
+pub mod z_getstandardfee;
 pub mod z_validate_address;
 pub mod zec;

zebra-rpc/src/methods/types/z_getstandardfee.rs

@@ -0,0 +1,20 @@
+//! Types for the `z_getstandardfee` RPC.
+
+use derive_getters::Getters;
+use derive_new::new;
+
+/// A response to a `z_getstandardfee` RPC request.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize, Getters, new)]
+pub struct ZGetStandardFeeResponse {
+    /// Recommended fee per logical action, in zatoshis.
+    #[getter(copy)]
+    pub(crate) standard_fee: u64,
+
+    /// Estimator version identifier.
+    #[getter(copy)]
+    pub(crate) version: u32,
+
+    /// The chain tip height at the time of computation.
+    #[getter(copy)]
+    pub(crate) height: u32,
+}