feat(rpc,node): submitblock pushes accepted blocks into BlockSync apply channel

Op: extend

Author: metaphorics

crates/node/src/run.rs

@@ -157,6 +157,7 @@ pub fn run(mut config: Config) -> Result<()> {
         state.peers(),
         state.block_tree(),
         state.config().network,
+        Some(state.inbound_blocks_sender()),
     );
     let rpc_handler = Arc::new(bitcoin_rs_rpc::Handler::new(Arc::new(rpc_context)));
     let rpc_server = bitcoin_rs_rpc::RpcServer::bind(

crates/node/tests/rpc_wiring.rs

@@ -35,6 +35,7 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
     let mining_template_id = state.mining_template_id();
     let peers = state.peers();
     let block_tree = state.block_tree();
+    let inbound_blocks_sender = state.inbound_blocks_sender();
 
     let ctx = Context::from_handles(
         Arc::clone(&chain_tip),
@@ -50,6 +51,7 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
         Arc::clone(&peers),
         Arc::clone(&block_tree),
         chain_network,
+        Some(inbound_blocks_sender),
     );
 
     assert!(
@@ -99,6 +101,10 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
         Arc::ptr_eq(&ctx.block_tree, &block_tree),
         "block_tree must share identity"
     );
+    assert!(
+        ctx.inbound_blocks_sender.is_some(),
+        "inbound_blocks_sender must be Some"
+    );
 
     Ok(())
 }

crates/rpc/src/context.rs

@@ -136,6 +136,10 @@ pub struct Context {
     pub mining_template_id: Arc<ArcSwap<CompactString>>,
     /// Receiver notified when mining template inputs change.
     pub mining_notifications: Receiver<()>,
+    /// Optional outbound channel that submits decoded blocks back to the node's
+    /// `BlockSync::tick` for the canonical apply path. `None` when no node is
+    /// wired (tests, embedded callers).
+    pub inbound_blocks_sender: Option<crossbeam_channel::Sender<bitcoin::Block>>,
     mining_sender: Sender<()>,
 }
 // SAFETY: `Context` is shared by RPC worker threads. Each mutable subsystem
@@ -184,6 +188,7 @@ impl Context {
             block_tree: Arc::new(parking_lot::RwLock::new(bitcoin_rs_chain::BlockTree::new())),
             mining_template_id: Arc::new(ArcSwap::from_pointee(CompactString::new("0"))),
             mining_notifications,
+            inbound_blocks_sender: None,
             mining_sender,
         }
     }
@@ -209,6 +214,7 @@ impl Context {
         peers: Arc<RwLock<Vec<bitcoin_rs_p2p::PeerInfo>>>,
         block_tree: Arc<parking_lot::RwLock<bitcoin_rs_chain::BlockTree>>,
         chain_network: Network,
+        inbound_blocks_sender: Option<crossbeam_channel::Sender<bitcoin::Block>>,
     ) -> Self {
         let (mining_sender, mining_notifications) = unbounded();
         Self {
@@ -226,6 +232,7 @@ impl Context {
             block_tree,
             mining_template_id,
             mining_notifications,
+            inbound_blocks_sender,
             mining_sender,
         }
     }
@@ -440,6 +447,7 @@ mod tests {
             Arc::new(RwLock::new(Vec::new())),
             Arc::clone(&block_tree),
             Network::Mainnet,
+            None,
         );
         assert!(
             Arc::ptr_eq(&ctx.chain_tip, &chain_tip),

crates/rpc/src/handlers/mining.rs

@@ -144,26 +144,27 @@ fn chainwork_to_f64(work: bitcoin_rs_chain::ChainWork) -> f64 {
         .fold(0.0_f64, |acc, &byte| acc.mul_add(256.0, f64::from(byte)))
 }
 
-pub(crate) fn submitblock(_ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
+pub(crate) fn submitblock(ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
     use bitcoin::consensus::encode::deserialize;
-    use bitcoin::hex::FromHex as _;
+    use bitcoin::hex::FromHex;
 
     let hex = required_str(params, 0, "block hex is required")?;
-    let bytes = Vec::<u8>::from_hex(hex)
+    let bytes = <Vec<u8> as FromHex>::from_hex(hex)
         .map_err(|_| RpcError::InvalidParams("block hex is not valid hexadecimal"))?;
     let block: bitcoin::Block = match deserialize(&bytes) {
-        Ok(block) => block,
+        Ok(b) => b,
         Err(_) => return Ok(json!("bad-block-encoding")),
     };
     let target = block.header.target();
     if block.header.validate_pow(target).is_err() {
         return Ok(json!("high-hash"));
     }
-
-    // TODO(node-channel): push block bytes to BlockSync via a Sender<Vec<u8>>;
-    // until then, accept the block as parseable + PoW-self-consistent and
-    // return null per Bitcoin Core's accept signal. Real apply will happen
-    // when the node-side channel is wired.
+    if let Some(sender) = &ctx.inbound_blocks_sender {
+        if sender.send(block).is_err() {
+            return Ok(json!("channel-closed"));
+        }
+    }
+    // Successful enqueue (or no-sender accept path) returns null.
     Ok(Value::new_null())
 }
 
@@ -205,6 +206,23 @@ mod submitblock_tests {
         );
     }
 
+    #[test]
+    fn submitblock_pushes_to_channel_when_present() {
+        let (tx, rx) = crossbeam_channel::unbounded::<bitcoin::Block>();
+        let mut ctx = Context::new();
+        ctx.inbound_blocks_sender = Some(tx);
+        let ctx = Arc::new(ctx);
+        let genesis = bitcoin::blockdata::constants::genesis_block(bitcoin::Network::Regtest);
+        let hex = serialize(&genesis).to_lower_hex_string();
+        let result = submitblock(&ctx, &json!([hex]))
+            .unwrap_or_else(|err| panic!("submitblock failed: {err}"));
+        assert!(result.is_null());
+        let received = rx
+            .try_recv()
+            .unwrap_or_else(|err| panic!("channel did not receive block: {err}"));
+        assert_eq!(received.block_hash(), genesis.block_hash());
+    }
+
     #[test]
     fn submitblock_rejects_garbage() {
         let ctx = Arc::new(Context::new());