feat(rpc)!: add getstandardfee RPC returning the ZIP-317 marginal fee (#10717)

* feat(rpc): add getstandardfee RPC returning the standard fee per logical action

Add a parameterless `getstandardfee` JSON-RPC method that returns the
recommended standard fee per logical action. This is the static interface
placeholder (version 0): it returns the existing ZIP-317 marginal fee (5000
zatoshis, reusing `MARGINAL_FEE` from zip317.rs) 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 }

Author: aphelionz

CHANGELOG.md

@@ -57,6 +57,10 @@ and this project adheres to [Semantic Versioning](https://semver.org).
 
 ### Added
 
+- Added the `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))
 - Support for the NU6.3 "Ironwood" shielded pool and v6 transaction format,
   activating on Testnet at height 4,134,000. The consensus parameters (v6 version
   group ID, consensus branch ID, and Testnet activation height) match

zebra-chain/src/transaction/unmined/zip317.rs

@@ -20,7 +20,7 @@ mod tests;
 /// The marginal fee for the ZIP-317 fee calculation, in zatoshis per logical action.
 //
 // TODO: allow Amount<NonNegative> in constants
-const MARGINAL_FEE: u64 = 5_000;
+pub const MARGINAL_FEE: u64 = 5_000;
 
 /// The number of grace logical actions allowed by the ZIP-317 fee calculation.
 const GRACE_ACTIONS: u32 = 2;

zebra-rpc/src/methods.rs

@@ -125,6 +125,7 @@ use types::{
     get_mempool_info::GetMempoolInfoResponse,
     get_mining_info::GetMiningInfoResponse,
     get_raw_mempool::{self, GetRawMempoolResponse},
+    get_standard_fee::GetStandardFeeResponse,
     long_poll::LongPollInput,
     network_info::{GetNetworkInfoResponse, NetworkInfo},
     peer_info::PeerInfo,
@@ -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: wallet
+    #[method(name = "getstandardfee")]
+    async fn get_standard_fee(&self) -> Result<GetStandardFeeResponse>;
+
     /// 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.
     ///
@@ -2858,6 +2869,14 @@ where
         z_validate_address(network, raw_address)
     }
 
+    async fn get_standard_fee(&self) -> Result<GetStandardFeeResponse> {
+        use zebra_chain::transaction::zip317::MARGINAL_FEE;
+
+        const VERSION: u32 = 0;
+
+        Ok(GetStandardFeeResponse::new(MARGINAL_FEE, VERSION))
+    }
+
     async fn get_block_subsidy(&self, height: Option<u32>) -> Result<GetBlockSubsidyResponse> {
         let net = self.network.clone();
 

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

@@ -3292,3 +3292,41 @@ 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_get_standard_fee() {
+    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();
+
+    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
+        .get_standard_fee()
+        .await
+        .expect("get_standard_fee should succeed");
+
+    // Static v0 placeholder: the ZIP-317 marginal fee and version 0.
+    assert_eq!(response.standard_fee(), 5000);
+    assert_eq!(response.version(), 0);
+}

zebra-rpc/src/methods/types.rs

@@ -6,6 +6,7 @@ pub mod get_blockchain_info;
 pub mod get_mempool_info;
 pub mod get_mining_info;
 pub mod get_raw_mempool;
+pub mod get_standard_fee;
 pub mod long_poll;
 pub mod network_info;
 pub mod peer_info;

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

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