feat(rpc): submit scoped CPFP packages through the gateway

crates/mempool/src/gateway.rs

@@ -202,6 +202,7 @@ pub(crate) enum AdmissionMode {
     SingleSubmit,
     PackageTest,
     PackageSubmit,
+    PackageRpcSubmit(Option<u64>),
 }
 
 #[allow(
@@ -216,6 +217,19 @@ enum ReplacementStage {
 }
 
 impl PreparedAdmission {
+    pub(crate) fn check_package_max_feerate(&mut self, maximum: Option<u64>) {
+        if self.rejection.is_none()
+            && self.fact.modified_fee.is_some_and(|fee| {
+                crate::standardness::exceeds_max_feerate(fee, self.fact.vsize, maximum)
+            })
+        {
+            self.reject(
+                AdmitError::Policy(crate::standardness::AcceptanceRejectReason::MaxFeeExceeded),
+                RejectScope::Transaction,
+            );
+        }
+    }
+
     fn reject(&mut self, error: AdmitError, scope: RejectScope) {
         self.replacement = ReplacementStage::Rejected;
         self.fact.allowed = Some(false);
@@ -1128,7 +1142,11 @@ impl MempoolGateway {
             _ => LimitEnforcement::Full,
         };
         let deferred = enforcement == LimitEnforcement::Deferred;
-        let floor = if deferred || mode == AdmissionMode::PackageSubmit {
+        let floor = if deferred
+            || matches!(
+                mode,
+                AdmissionMode::PackageSubmit | AdmissionMode::PackageRpcSubmit(_)
+            ) {
             None
         } else {
             Some(pool.min_fee_sat_per_kvb(bitcoin_rs_primitives::unix_time_secs()))
@@ -1183,7 +1201,9 @@ impl MempoolGateway {
         }
         if matches!(
             mode,
-            AdmissionMode::PackageTest | AdmissionMode::PackageSubmit
+            AdmissionMode::PackageTest
+                | AdmissionMode::PackageSubmit
+                | AdmissionMode::PackageRpcSubmit(_)
         ) {
             // Package previews and native submissions forbid replacement;
             // an already resident tx retains its duplicate result here.

crates/mempool/src/lib.rs

@@ -73,4 +73,5 @@ pub use rbf::{RbfError, required_fee};
 pub use rbf::{ReplacementCandidate, ReplacementPlan};
 pub use reader::MempoolReader;
 pub use standardness::{StandardnessError, StandardnessPolicy, is_standard_tx};
+pub use submit_package::{PackageSubmission, PackageTxResult};
 pub use truc::TrucError;

crates/mempool/src/package.rs

@@ -55,6 +55,7 @@ pub(crate) fn unfinished(tx: &Tx) -> TxAcceptanceFact {
         sigop_cost: 0,
         base_fee: None,
         effective_fee_rate: None,
+        modified_fee: None,
         reject_reason: None,
     }
 }
@@ -182,6 +183,14 @@ pub(crate) fn finish_package(
     };
     for (index, (job, request)) in prepared.iter_mut().zip(requests).enumerate() {
         job.verify_policy(request);
+        if let crate::gateway::AdmissionMode::PackageRpcSubmit(maximum) = mode
+            // Core's singleton PreChecks applies its own floor before the
+            // client cap. Multi-transaction caps precede aggregate fee checks.
+            && (txs.len() > 1
+                || aggregate_error != Some(AcceptanceRejectReason::MinRelayFeeNotMet))
+        {
+            job.check_package_max_feerate(maximum);
+        }
         if job.fact.allowed == Some(false) {
             facts.results[index] = job.fact.clone();
             return facts;
@@ -194,6 +203,16 @@ pub(crate) fn finish_package(
         facts.package_error = Some(error.into());
         return facts;
     }
+    // Core runs the combined package fee check before package RBF, cluster
+    // limits, and ephemeral-spend checks (validation.cpp `PreChecks` order).
+    // Only the aggregate fee failure takes that precedence; other planner
+    // errors (capacity, arithmetic, insert preflight) keep the ordering
+    // they had before it was introduced and report after the ephemeral
+    // check below.
+    if let Some(error @ AcceptanceRejectReason::MinRelayFeeNotMet) = aggregate_error {
+        facts.package_error = Some(error);
+        return facts;
+    }
     match checks
         .graph
         .and_then(|graph| graph.check_limits(checks.limits))
@@ -208,11 +227,17 @@ pub(crate) fn finish_package(
         Err(error) => {
             // Preserve the existing preview error surface. Native submission
             // reports pool/graph failures without pretending to run replacement.
-            facts.package_error = Some(if mode == crate::gateway::AdmissionMode::PackageSubmit {
-                AcceptanceRejectReason::Mempool(error.into_pool_error())
-            } else {
-                AcceptanceRejectReason::Replacement(error)
-            });
+            facts.package_error = Some(
+                if matches!(
+                    mode,
+                    crate::gateway::AdmissionMode::PackageSubmit
+                        | crate::gateway::AdmissionMode::PackageRpcSubmit(_)
+                ) {
+                    AcceptanceRejectReason::Mempool(error.into_pool_error())
+                } else {
+                    AcceptanceRejectReason::Replacement(error)
+                },
+            );
             return facts;
         }
     }