stop using util in FFIChainWatchInterface

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -197,6 +197,8 @@ pub mod chain_watch_interface_fn {
     pub type InstallWatchOutpointPtr = extern "cdecl" fn(outpoint: *const FFIOutPoint, out_script: *const FFIScript);
     pub type WatchAllTxnPtr = extern "cdecl" fn();
     pub type GetChainUtxoPtr = extern "cdecl" fn(genesis_hash: *const Bytes32, unspent_tx_output_identifier: u64, err: *mut FFIChainError, script_ptr: *mut u8, script_len: *mut usize, amount_satoshis: *mut u64);
+    pub type FilterBlock = extern "cdecl" fn(block_ptr: *const u8, block_len: usize, matched_index_ptr: *mut u8, matched_inedx_len: *mut usize);
+    pub type ReEntered = extern "cdecl" fn() -> usize;
 }
 
 #[repr(C)]
@@ -205,14 +207,17 @@ pub struct FFIChainWatchInterface {
     pub install_watch_outpoint_ptr: chain_watch_interface_fn::InstallWatchOutpointPtr,
     pub watch_all_txn_ptr: chain_watch_interface_fn::WatchAllTxnPtr,
     pub get_chain_utxo_ptr: chain_watch_interface_fn::GetChainUtxoPtr,
-    util: ChainWatchInterfaceUtil
+    pub filter_block_ptr: chain_watch_interface_fn::FilterBlock,
+    pub reentered_ptr: chain_watch_interface_fn::ReEntered
 }
 impl FFIChainWatchInterface {
     pub fn new(
         install_watch_tx: chain_watch_interface_fn::InstallWatchTxPtr,
         install_watch_outpoint: chain_watch_interface_fn::InstallWatchOutpointPtr,
         watch_all_txn: chain_watch_interface_fn::WatchAllTxnPtr,
         get_chain_utxo: chain_watch_interface_fn::GetChainUtxoPtr,
+        filter_block: chain_watch_interface_fn::FilterBlock,
+        reentered: chain_watch_interface_fn::ReEntered,
         network: Network,
         logger: Arc<dyn Logger>
     ) -> FFIChainWatchInterface {
@@ -221,38 +226,30 @@ impl FFIChainWatchInterface {
             install_watch_outpoint_ptr: install_watch_outpoint,
             watch_all_txn_ptr: watch_all_txn,
             get_chain_utxo_ptr: get_chain_utxo,
-            util: ChainWatchInterfaceUtil::new(network)
+            filter_block_ptr: filter_block,
+            reentered_ptr:reentered
         }
     }
 }
 
 impl ChainWatchInterface for FFIChainWatchInterface {
     fn install_watch_tx(&self, txid: &Txid, script_pub_key: &Script) {
-        self.util.install_watch_tx(txid, script_pub_key);
         let spk_vec = bitcoin_serialize(script_pub_key);
         let ffi_spk = FFIScript::from(spk_vec.as_slice());
         let txid: Bytes32 = txid.clone().into();
         (self.install_watch_tx_ptr)(&txid as *const _, &ffi_spk as *const _)
     }
     fn install_watch_outpoint(&self, outpoint: (Txid, u32), out_script: &Script) {
-        self.util.install_watch_outpoint(outpoint, out_script);
         let txid: Bytes32 = outpoint.0.into();
         let ffi_outpoint = FFIOutPoint { txid: txid, index: outpoint.1 as u16 };
         let out_script_vec = bitcoin_serialize(out_script);
         let ffi_outscript = FFIScript::from(out_script_vec.as_slice());
         (self.install_watch_outpoint_ptr)(&ffi_outpoint as *const _, &ffi_outscript as *const _)
     }
     fn watch_all_txn(&self) {
-        self.util.watch_all_txn();
         (self.watch_all_txn_ptr)()
     }
     fn get_chain_utxo(&self, genesis_hash: BlockHash, unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError> {
-        match self.util.get_chain_utxo(genesis_hash, unspent_tx_output_identifier) {
-            Err(ChainError::NotWatched) => {
-                return Err(ChainError::NotWatched);
-            },
-            _ =>  {},
-        }
         let err = std::ptr::null_mut();
         // the length can be anything as long as it is enough to put the scriptPubKey.
         // probably this is a bit overkill but who cares.
@@ -270,11 +267,30 @@ impl ChainWatchInterface for FFIChainWatchInterface {
             Err(e.into())
         }
     }
+
     fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
-        self.util.filter_block(block)
+        let block_bytes = bitcoin_serialize(block);
+        // the minimum weight for one tx is 440. So the max number of tx in one block is 9090.
+        // so the max size of the buffer we have to prepare is.
+        // `2 + (9090 * 4) = 36362`.
+        let mut matched_tx_index = [0u8; 36864];
+        let mut matched_tx_index_len_ptr: &mut usize = todo!();
+        println!("coinbase tx in rl {:?}", block.txdata[0]);
+        (self.filter_block_ptr)(block_bytes.as_ptr(), block_bytes.len(), matched_tx_index.as_mut_ptr(), matched_tx_index_len_ptr as *mut _);
+        if (matched_tx_index_len_ptr.clone() == usize::MAX) {
+            panic!("FFI failure. the caller must set the actual serialized length of the tx-indexes in filter_block");
+        }
+        let mut matched_tx_index: &[u8] = unsafe_block!("We know the caller has set the value for serialized tx index" => &matched_tx_index[..(*matched_tx_index_len_ptr)]);
+        let matched_tx_indexes: Vec<u32> = lightning::util::ser::Readable::read(&mut std::io::Cursor::new(matched_tx_index)).unwrap();
+        let mut matched_txs = Vec::with_capacity(matched_tx_indexes.len());
+        for i in matched_tx_indexes.iter() {
+            matched_txs.push(&block.txdata[i.clone() as usize]);
+        }
+        (matched_txs, matched_tx_indexes)
     }
+
     fn reentered(&self) -> usize {
-        self.util.reentered()
+        (self.reentered_ptr)()
     }
 }
 

bindings/src/adaptors/primitives.rs

@@ -280,7 +280,7 @@ pub struct FFIEvents {
 
 impl Writeable for FFIEvents {
     fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-        (self.events.len() as u16).write(writer);
+        (self.events.len() as u16).write(writer)?;
         for e in &self.events {
             match e {
                 Event::FundingGenerationReady {ref temporary_channel_id, ref channel_value_satoshis, ref output_script, ref user_channel_id} => {

bindings/src/blocknotifier.rs

@@ -19,10 +19,14 @@ ffi! {
     fn create_block_notifier(
         network_ref: FFINetwork,
         log_ptr: Ref<ffilogger_fn::LogExtern>,
+
         install_watch_tx_ptr: Ref<chain_watch_interface_fn::InstallWatchTxPtr>,
         install_watch_outpoint_ptr: Ref<chain_watch_interface_fn::InstallWatchOutpointPtr>,
         watch_all_txn_ptr: Ref<chain_watch_interface_fn::WatchAllTxnPtr>,
         get_chain_utxo_ptr: Ref<chain_watch_interface_fn::GetChainUtxoPtr>,
+        filter_block_ptr: Ref<chain_watch_interface_fn::FilterBlock>,
+        reentered_ptr: Ref<chain_watch_interface_fn::ReEntered>,
+
         handle: Out<FFIBlockNotifierHandle>
     ) -> FFIResult {
         let network = network_ref.to_network();
@@ -33,12 +37,17 @@ ffi! {
         let install_watch_outpoint_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => install_watch_outpoint_ptr.as_ref());
         let watch_all_txn_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => watch_all_txn_ptr.as_ref());
         let get_chain_utxo_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => get_chain_utxo_ptr.as_ref());
+        let filter_block_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => filter_block_ptr.as_ref());
+        let reentered_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => reentered_ptr.as_ref());
+
         let chain_watch_interface_arc =
             Arc::new(FFIChainWatchInterface::new(
                 *install_watch_tx_ref,
                 *install_watch_outpoint_ref,
                 *watch_all_txn_ref,
                 *get_chain_utxo_ref,
+                *filter_block_ref,
+                *reentered_ref,
                 network,
                 logger_arc.clone()
             ));

bindings/src/channelmanager.rs

@@ -83,6 +83,8 @@ pub(crate) fn construct_channel_manager(
     install_watch_outpoint: &chain_watch_interface_fn::InstallWatchOutpointPtr,
     watch_all_txn: &chain_watch_interface_fn::WatchAllTxnPtr,
     get_chain_utxo: &chain_watch_interface_fn::GetChainUtxoPtr,
+    filter_block: &chain_watch_interface_fn::FilterBlock,
+    reentered: &chain_watch_interface_fn::ReEntered,
 
     broadcast_transaction_ptr: Ref<broadcaster_fn::BroadcastTransactionPtr>,
     log_ref: &ffilogger_fn::LogExtern,
@@ -98,11 +100,13 @@ pub(crate) fn construct_channel_manager(
 
     let chain_watch_interface_arc =
         Arc::new(FFIChainWatchInterface::new(
-             *install_watch_tx,
+            *install_watch_tx,
             *install_watch_outpoint,
             *watch_all_txn,
             *get_chain_utxo,
-                network,
+            *filter_block,
+            *reentered,
+            network,
             logger_arc.clone()
         ));
 
@@ -141,6 +145,8 @@ ffi! {
         install_watch_outpoint_ptr: Ref<chain_watch_interface_fn::InstallWatchOutpointPtr>,
         watch_all_txn_ptr: Ref<chain_watch_interface_fn::WatchAllTxnPtr>,
         get_chain_utxo_ptr: Ref<chain_watch_interface_fn::GetChainUtxoPtr>,
+        filter_block_ptr: Ref<chain_watch_interface_fn::FilterBlock>,
+        reentered_ptr: Ref<chain_watch_interface_fn::ReEntered>,
 
         broadcast_transaction_ptr: Ref<broadcaster_fn::BroadcastTransactionPtr>,
         log_ptr: Ref<ffilogger_fn::LogExtern>,
@@ -154,15 +160,21 @@ ffi! {
         let install_watch_outpoint_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => install_watch_outpoint_ptr.as_ref());
         let watch_all_txn_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => watch_all_txn_ptr.as_ref());
         let get_chain_utxo_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => get_chain_utxo_ptr.as_ref());
+        let filter_block_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => filter_block_ptr.as_ref());
+        let reentered_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => reentered_ptr.as_ref());
+
         let chan_man_raw =
             construct_channel_manager(
                 seed,
                 network,
                 cfg,
+
                 install_watch_tx_ref,
                 install_watch_outpoint_ref,
                 watch_all_txn_ref,
                 get_chain_utxo_ref,
+                filter_block_ref,
+                reentered_ref,
 
                 broadcast_transaction_ptr,
                 log_ref,

bindings/src/peermanager.rs

@@ -52,6 +52,9 @@ ffi! {
         install_watch_outpoint_ptr: Ref<chain_watch_interface_fn::InstallWatchOutpointPtr>,
         watch_all_txn_ptr: Ref<chain_watch_interface_fn::WatchAllTxnPtr>,
         get_chain_utxo_ptr: Ref<chain_watch_interface_fn::GetChainUtxoPtr>,
+        filter_block_ptr: Ref<chain_watch_interface_fn::FilterBlock>,
+        reentered_ptr: Ref<chain_watch_interface_fn::ReEntered>,
+
         log_ptr: Ref<ffilogger_fn::LogExtern>,
 
         our_node_secret_ptr: Ref<Bytes32>,
@@ -74,13 +77,18 @@ ffi! {
         let install_watch_outpoint_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => install_watch_outpoint_ptr.as_ref());
         let watch_all_txn_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => watch_all_txn_ptr.as_ref());
         let get_chain_utxo_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => get_chain_utxo_ptr.as_ref());
+        let filter_block_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => filter_block_ptr.as_ref());
+        let reentered_ref = unsafe_block!("function pointer lives as long as ChainWatchInterface and it points to valid data"  => reentered_ptr.as_ref());
+
         let logger_arc = Arc::new(FFILogger { log_ptr: *log_ref });
         let chain_watch_interface_arc =
             Arc::new(FFIChainWatchInterface::new(
                 *install_watch_tx_ref,
                 *install_watch_outpoint_ref,
                 *watch_all_txn_ref,
                 *get_chain_utxo_ref,
+                *filter_block_ref,
+                *reentered_ref,
                 network.to_network(),
                 logger_arc.clone()
             ));