remove script cache

tamasblummer · tamasblummer · commit 190c41c0b284 · 2019-01-28T17:35:52.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -25,7 +25,6 @@ log = "0.4"
 simple_logger = "0.5.0"
 rusqlite = { version = "0.13.0", features = ["bundled"] }
 byteorder = "1.2"
-lru-cache = "0.1.1"
 rayon = "1.0.3"
 futures={ git= "https://github.com/tamasblummer/futures-rs.git", tag = "0.2.1" }
 futures-timer= { git= "https://github.com/tamasblummer/futures-timer.git", branch = "futures_0.2.1" }
diff --git a/src/bin/client.rs b/src/bin/client.rs
@@ -69,8 +69,6 @@ pub fn main() {
         }
     }
 
-    let cache = 0;
-
     let mut peers = get_peers();
     if peers.is_empty () {
         peers.push(SocketAddr::from(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8333)));
@@ -82,10 +80,10 @@ pub fn main() {
     let mut spv;
     let listen = get_listeners();
     if let Some(path) = find_arg("db") {
-        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()),  listen, false,cache).unwrap();
+        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()),  listen, false).unwrap();
     }
     else {
-        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("client.db"), listen, false,cache).unwrap();
+        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("client.db"), listen, false).unwrap();
     }
     spv.run(peers, connections, true).expect("can not start SPV");
 }
diff --git a/src/bin/server.rs b/src/bin/server.rs
@@ -39,14 +39,12 @@ pub fn main() {
         println!("--network net: net is one of main|test for corresponding Bitcoin networks");
         println!("--listen ip_address:port : accept incoming connection requests");
         println!("--nodns : do not use dns seed");
-        println!("--cache : cache of utxo in millions - set it up to 60 if doing initial load and you have plenty of RAM");
         println!("defaults:");
         println!("--db server.db");
         println!("--log debug");
         println!("--listen 127.0.0.1:8333");
         println!("--connections 1");
         println!("--network main");
-        println!("--cache 1");
         println!("in memory database");
         return;
     }
@@ -73,11 +71,6 @@ pub fn main() {
         }
     }
 
-    let mut cache = 1024usize *1024usize;
-    if let Some(numstring) = find_arg("cache") {
-        cache *= numstring.parse::<usize>().unwrap() as usize;
-    }
-
     let peers = get_peers();
     let mut connections = 1;
     if let Some(numstring) = find_arg("connections") {
@@ -89,10 +82,10 @@ pub fn main() {
         listen.push(SocketAddr::from(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8333)));
     }
     if let Some(path) = find_arg("db") {
-        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()),  listen, true, cache).unwrap();
+        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()),  listen, true).unwrap();
     }
     else {
-        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("server.db"), listen, true, cache).unwrap();
+        spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("server.db"), listen, true).unwrap();
     }
     spv.run(peers, connections, find_opt("nodns")).expect("can not start SPV");
 }
diff --git a/src/blockfilter.rs b/src/blockfilter.rs
@@ -59,12 +59,12 @@ pub struct BlockFilter {
 
 impl BlockFilter {
 
-    pub fn compute_script_filter(block: &Block, utxo: impl ScriptAccessor) -> Result<BlockFilter, SPVError> {
+    pub fn compute_script_filter(block: &Block, height: u32, script_accessor: impl ScriptAccessor) -> Result<BlockFilter, SPVError> {
         let mut bytes = Vec::new();
         let mut out = Cursor::new(&mut bytes);
         {
             let mut writer = BlockFilterWriter::new(&mut out, block);
-            writer.script_filter(utxo)?;
+            writer.script_filter(height, script_accessor)?;
             writer.finish()?;
         }
         Ok(BlockFilter{block: block.bitcoin_hash(), filter_type: SCRIPT_FILTER, content: out.into_inner().to_vec()})
@@ -108,7 +108,7 @@ impl <'a> BlockFilterWriter<'a> {
     }
 
     /// Add consumed output scripts of a block to filter
-    fn add_consumed_scripts (&mut self, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
+    fn add_consumed_scripts (&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
         let mut coins = Vec::new();
         for transaction in &self.block.txdata {
             if !transaction.is_coin_base() {
@@ -117,16 +117,16 @@ impl <'a> BlockFilterWriter<'a> {
                 }
             }
         }
-        for script in tx_accessor.get_scripts(coins)? {
+        for script in tx_accessor.get_scripts(height, coins)? {
             self.writer.add_element(script.as_bytes());
         }
         Ok(())
     }
 
     /// compile a filter useful for wallets
-    pub fn script_filter(&mut self, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
+    pub fn script_filter(&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
         self.add_output_scripts();
-        self.add_consumed_scripts(tx_accessor)
+        self.add_consumed_scripts(height, tx_accessor)
     }
 
     /// compile a filter useful to find spent outputs
@@ -432,7 +432,7 @@ mod test {
     }
 
     impl ScriptAccessor for HashMap<OutPoint, Script> {
-        fn get_scripts(&self, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {
+        fn get_scripts(&self, _: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {
             let mut result = Vec::new();
             for coin in coins {
                 if let Some(ux) = self.get(&coin) {
@@ -483,7 +483,7 @@ mod test {
             let mut constructed_filter = Cursor::new(Vec::new());
             {
                 let mut writer = BlockFilterWriter::new(&mut constructed_filter, &block);
-                writer.script_filter(txmap).unwrap();
+                writer.script_filter(0, txmap).unwrap();
                 writer.finish().unwrap();
             }
 
diff --git a/src/chaindb.rs b/src/chaindb.rs
@@ -35,7 +35,6 @@ use error::SPVError;
 use filtercache::FilterCache;
 use headercache::{HeaderCache, HeaderIterator};
 use blockfilter::{BlockFilter, BlockFilterReader, COIN_FILTER, SCRIPT_FILTER};
-use scriptcache::ScriptCache;
 
 use hammersbald::{
     BitcoinAdaptor, HammersbaldAPI, persistent, PRef,
@@ -60,38 +59,35 @@ pub struct ChainDB {
     heavy: Option<BitcoinAdaptor>,
     headercache: HeaderCache,
     filtercache: FilterCache,
-    scriptcache: Mutex<ScriptCache>,
     network: Network,
 }
 
 impl ChainDB {
     /// Create an in-memory database instance
-    pub fn mem(network: Network, heavy: bool, server: bool, script_cache_size: usize) -> Result<ChainDB, SPVError> {
+    pub fn mem(network: Network, heavy: bool, server: bool) -> Result<ChainDB, SPVError> {
         info!("working with in memory chain db");
         let light = BitcoinAdaptor::new(transient(2)?);
         let headercache = HeaderCache::new(network);
         let filtercache = FilterCache::new(server);
-        let scriptcache = Mutex::new(ScriptCache::new(script_cache_size));
         if heavy {
             let heavy = Some(BitcoinAdaptor::new(transient(2)?));
-            Ok(ChainDB { light, heavy, network, headercache, filtercache, scriptcache })
+            Ok(ChainDB { light, heavy, network, headercache, filtercache })
         } else {
-            Ok(ChainDB { light, heavy: None, network, headercache, filtercache, scriptcache })
+            Ok(ChainDB { light, heavy: None, network, headercache, filtercache })
         }
     }
 
     /// Create or open a persistent database instance identified by the path
-    pub fn new(path: &Path, network: Network, heavy: bool, server: bool, script_cache_size: usize) -> Result<ChainDB, SPVError> {
+    pub fn new(path: &Path, network: Network, heavy: bool, server: bool) -> Result<ChainDB, SPVError> {
         let basename = path.to_str().unwrap().to_string();
         let light = BitcoinAdaptor::new(persistent((basename.clone() + ".h").as_str(), 100, 2)?);
         let headercache = HeaderCache::new(network);
         let filtercache = FilterCache::new(server);
-        let scriptcache = Mutex::new(ScriptCache::new(script_cache_size));
         if heavy {
             let heavy = Some(BitcoinAdaptor::new(persistent((basename + ".b").as_str(), 1000, 2)?));
-            Ok(ChainDB { light, heavy, network, headercache, filtercache, scriptcache })
+            Ok(ChainDB { light, heavy, network, headercache, filtercache })
         } else {
-            Ok(ChainDB { light, heavy: None, network, headercache, filtercache, scriptcache })
+            Ok(ChainDB { light, heavy: None, network, headercache, filtercache })
         }
     }
 
@@ -322,44 +318,17 @@ impl ChainDB {
         panic!("should not call store block before header is known {}", block.bitcoin_hash());
     }
 
-    pub fn cache_scripts(&mut self, block: &Block, height: u32) {
-        let block_id = Arc::new(block.bitcoin_hash());
-        let mut script_cache = self.scriptcache.lock().unwrap();
-        for (i, tx) in block.txdata.iter().enumerate() {
-            let tx_nr = i as u32;
-            let txid = tx.txid();
-            for (idx, output) in tx.output.iter().enumerate() {
-                let vout = idx as u32;
-                if !output.script_pubkey.is_provably_unspendable() {
-                    script_cache.insert(OutPoint{txid, vout}, output.script_pubkey.clone(), height);
-                }
-            }
-        }
-    }
-
-    pub fn get_scripts(&self, coins: Vec<OutPoint>, mut sofar: Vec<Script>) -> Result<Vec<Script>, SPVError> {
-        let mut remains = Vec::with_capacity(coins.len());
-        {
-            // check in script cache
-            let mut scriptcache = self.scriptcache.lock().unwrap();
-            for coin in coins {
-                if let Some(script) = scriptcache.remove(&coin) {
-                    sofar.push(script);
-                }
-                else {
-                    let mut buf = Vec::new();
-                    coin.consensus_encode(&mut buf)?;
-                    remains.push(buf);
-                }
-            }
-        }
+    pub fn get_scripts(&self, height: u32, coins: Vec<OutPoint>, mut sofar: Vec<Script>) -> Result<Vec<Script>, SPVError> {
+        let mut remains = coins.iter().map(|coin| {
+            let mut buf = Vec::new();
+            coin.consensus_encode(&mut buf).unwrap();
+            buf
+        }).collect::<Vec<_>>();
         remains.sort();
         if remains.len() > 0 {
-            let from = self.scriptcache.lock().unwrap().complete_after();
-
             let mapped = remains.par_chunks(100).map(|remains| {
                 let remains = remains.to_vec();
-                self.resolve_with_filters(from, remains)
+                self.resolve_with_filters(height, remains)
             }).flatten().collect::<Vec<_>>();
             sofar.extend (mapped);
         }
@@ -592,11 +561,11 @@ impl<'a> DBScriptAccessor<'a> {
 
 
 pub trait ScriptAccessor {
-    fn get_scripts(&self, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError>;
+    fn get_scripts(&self, height: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError>;
 }
 
 impl<'a> ScriptAccessor for DBScriptAccessor<'a> {
-    fn get_scripts(&self, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {
+    fn get_scripts(&self, height: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {
         let mut sofar = Vec::with_capacity(coins.len());
         let mut remains = Vec::with_capacity(coins.len());
         for coin in coins {
@@ -607,6 +576,6 @@ impl<'a> ScriptAccessor for DBScriptAccessor<'a> {
                 remains.push(coin);
             }
         }
-        self.db.get_scripts(remains, sofar)
+        self.db.get_scripts(height, remains, sofar)
     }
 }
diff --git a/src/constructor.rs b/src/constructor.rs
@@ -85,9 +85,9 @@ impl Constructor {
     ///      db - file path to data
     /// The method will read previously stored headers from the database and sync up with the peers
     /// then serve the returned ChainWatchInterface
-    pub fn new(user_agent :String, network: Network, path: &Path, listen: Vec<SocketAddr>, server: bool, script_cache_size: usize) -> Result<Constructor, SPVError> {
+    pub fn new(user_agent :String, network: Network, path: &Path, listen: Vec<SocketAddr>, server: bool) -> Result<Constructor, SPVError> {
         let configdb = Arc::new(Mutex::new(ConfigDB::new(path)?));
-        let chaindb = Arc::new(RwLock::new(ChainDB::new(path, network,server, server, script_cache_size)?));
+        let chaindb = Arc::new(RwLock::new(ChainDB::new(path, network,server, server)?));
         create_tables(configdb.clone())?;
         Ok(Constructor { network, user_agent, configdb, chaindb, listen, server, connector: None })
     }
@@ -98,9 +98,9 @@ impl Constructor {
     ///      bootstrap - peer adresses (only tested to work with one local node for now)
     /// The method will start with an empty in-memory database and sync up with the peers
     /// then serve the returned ChainWatchInterface
-    pub fn new_in_memory(user_agent :String, network: Network, listen: Vec<SocketAddr>, server: bool, script_cache_size: usize) -> Result<Constructor, SPVError> {
+    pub fn new_in_memory(user_agent :String, network: Network, listen: Vec<SocketAddr>, server: bool) -> Result<Constructor, SPVError> {
         let configdb = Arc::new(Mutex::new(ConfigDB::mem()?));
-        let chaindb = Arc::new(RwLock::new(ChainDB::mem( network,server, server, script_cache_size)?));
+        let chaindb = Arc::new(RwLock::new(ChainDB::mem( network,server, server)?));
         create_tables(configdb.clone())?;
         Ok(Constructor { network, user_agent, configdb, chaindb, listen, server, connector: None })
     }
diff --git a/src/filtercalculator.rs b/src/filtercalculator.rs
@@ -159,10 +159,9 @@ impl FilterCalculator {
                     if missing.last().is_some() && *missing.last().unwrap() == genesis.bitcoin_hash() {
                         let mut chaindb = self.chaindb.write().unwrap();
                         let block_ref = chaindb.store_block(&genesis)?;
-                        let script_filter = BlockFilter::compute_script_filter(&genesis, chaindb.get_script_accessor(&genesis))?;
+                        let script_filter = BlockFilter::compute_script_filter(&genesis, 0, chaindb.get_script_accessor(&genesis))?;
                         let coin_filter = BlockFilter::compute_coin_filter(&genesis)?;
                         chaindb.store_known_filter(&Sha256dHash::default(), &Sha256dHash::default(), &script_filter, &coin_filter)?;
-                        chaindb.cache_scripts(&genesis, 0);
                         chaindb.batch()?;
                         let len = missing.len();
                         missing.truncate(len - 1);
@@ -195,17 +194,15 @@ impl FilterCalculator {
             if let Some(header) = chaindb.get_header(&block_id) {
                 // do not store fake blocks
                 if block.check_merkle_root() && block.check_witness_commitment() {
-                    // cache output scripts for later calculation
-                    chaindb.cache_scripts(block, header.height);
                     // if this is the next block for filter calculation
                     if let Some(prev_script) = chaindb.get_block_filter(&block.header.prev_blockhash, SCRIPT_FILTER) {
                         if let Some(prev_coin) = chaindb.get_block_filter(&block.header.prev_blockhash, COIN_FILTER) {
+                            // calculate filters
+                            let script_filter = BlockFilter::compute_script_filter(&block, header.height, chaindb.get_script_accessor(block))?;
+                            let coin_filter = BlockFilter::compute_coin_filter(&block)?;
                             // store block
                             debug!("store block  {} {} peer={}", header.height, block_id, peer);
                             chaindb.store_block(block)?;
-                            // calculate filters
-                            let script_filter = BlockFilter::compute_script_filter(&block, chaindb.get_script_accessor(block))?;
-                            let coin_filter = BlockFilter::compute_coin_filter(&block)?;
                             debug!("store filter {} {} size: {} {} peer={}", header.height, block_id, script_filter.content.len(), coin_filter.content.len(), peer);
                             // store known filters into header
                             chaindb.store_known_filter(&prev_script.bitcoin_hash(), &prev_coin.bitcoin_hash(), &script_filter, &coin_filter)?;
diff --git a/src/lib.rs b/src/lib.rs
@@ -37,15 +37,13 @@ extern crate log;
 extern crate rand;
 extern crate rusqlite;
 extern crate siphasher;
-extern crate lru_cache;
 extern crate futures;
 extern crate futures_timer;
 
 mod filterdownload;
 mod ping;
 mod timeout;
 mod blockserver;
-mod scriptcache;
 mod filterserver;
 mod headerdownload;
 mod headercache;
diff --git a/src/scriptcache.rs b/src/scriptcache.rs
diff --git a/tests/download.rs b/tests/download.rs

Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,6 @@ pub fn main() {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`- let cache = 0;`
`73`		`-`
`74`	`72`	`let mut peers = get_peers();`
`75`	`73`	`if peers.is_empty () {`
`76`	`74`	`peers.push(SocketAddr::from(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8333)));`
`@@ -82,10 +80,10 @@ pub fn main() {`
`82`	`80`	`let mut spv;`
`83`	`81`	`let listen = get_listeners();`
`84`	`82`	`if let Some(path) = find_arg("db") {`
`85`		`- spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()), listen, false,cache).unwrap();`
	`83`	`+ spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()), listen, false).unwrap();`
`86`	`84`	`}`
`87`	`85`	`else {`
`88`		`- spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("client.db"), listen, false,cache).unwrap();`
	`86`	`+ spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("client.db"), listen, false).unwrap();`
`89`	`87`	`}`
`90`	`88`	`spv.run(peers, connections, true).expect("can not start SPV");`
`91`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,14 +39,12 @@ pub fn main() {`
`39`	`39`	`println!("--network net: net is one of main\|test for corresponding Bitcoin networks");`
`40`	`40`	`println!("--listen ip_address:port : accept incoming connection requests");`
`41`	`41`	`println!("--nodns : do not use dns seed");`
`42`		`- println!("--cache : cache of utxo in millions - set it up to 60 if doing initial load and you have plenty of RAM");`
`43`	`42`	`println!("defaults:");`
`44`	`43`	`println!("--db server.db");`
`45`	`44`	`println!("--log debug");`
`46`	`45`	`println!("--listen 127.0.0.1:8333");`
`47`	`46`	`println!("--connections 1");`
`48`	`47`	`println!("--network main");`
`49`		`- println!("--cache 1");`
`50`	`48`	`println!("in memory database");`
`51`	`49`	`return;`
`52`	`50`	`}`
`@@ -73,11 +71,6 @@ pub fn main() {`
`73`	`71`	`}`
`74`	`72`	`}`
`75`	`73`
`76`		`- let mut cache = 1024usize *1024usize;`
`77`		`- if let Some(numstring) = find_arg("cache") {`
`78`		`- cache *= numstring.parse::<usize>().unwrap() as usize;`
`79`		`- }`
`80`		`-`
`81`	`74`	`let peers = get_peers();`
`82`	`75`	`let mut connections = 1;`
`83`	`76`	`if let Some(numstring) = find_arg("connections") {`
`@@ -89,10 +82,10 @@ pub fn main() {`
`89`	`82`	`listen.push(SocketAddr::from(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8333)));`
`90`	`83`	`}`
`91`	`84`	`if let Some(path) = find_arg("db") {`
`92`		`- spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()), listen, true, cache).unwrap();`
	`85`	`+ spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new(path.as_str()), listen, true).unwrap();`
`93`	`86`	`}`
`94`	`87`	`else {`
`95`		`- spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("server.db"), listen, true, cache).unwrap();`
	`88`	`+ spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("server.db"), listen, true).unwrap();`
`96`	`89`	`}`
`97`	`90`	`spv.run(peers, connections, find_opt("nodns")).expect("can not start SPV");`
`98`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,12 @@ pub struct BlockFilter {`
`59`	`59`
`60`	`60`	`impl BlockFilter {`
`61`	`61`
`62`		`- pub fn compute_script_filter(block: &Block, utxo: impl ScriptAccessor) -> Result<BlockFilter, SPVError> {`
	`62`	`+ pub fn compute_script_filter(block: &Block, height: u32, script_accessor: impl ScriptAccessor) -> Result<BlockFilter, SPVError> {`
`63`	`63`	`let mut bytes = Vec::new();`
`64`	`64`	`let mut out = Cursor::new(&mut bytes);`
`65`	`65`	`{`
`66`	`66`	`let mut writer = BlockFilterWriter::new(&mut out, block);`
`67`		`- writer.script_filter(utxo)?;`
	`67`	`+ writer.script_filter(height, script_accessor)?;`
`68`	`68`	`writer.finish()?;`
`69`	`69`	`}`
`70`	`70`	`Ok(BlockFilter{block: block.bitcoin_hash(), filter_type: SCRIPT_FILTER, content: out.into_inner().to_vec()})`
`@@ -108,7 +108,7 @@ impl <'a> BlockFilterWriter<'a> {`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`/// Add consumed output scripts of a block to filter`
`111`		`- fn add_consumed_scripts (&mut self, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {`
	`111`	`+ fn add_consumed_scripts (&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {`
`112`	`112`	`let mut coins = Vec::new();`
`113`	`113`	`for transaction in &self.block.txdata {`
`114`	`114`	`if !transaction.is_coin_base() {`
`@@ -117,16 +117,16 @@ impl <'a> BlockFilterWriter<'a> {`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`120`		`- for script in tx_accessor.get_scripts(coins)? {`
	`120`	`+ for script in tx_accessor.get_scripts(height, coins)? {`
`121`	`121`	`self.writer.add_element(script.as_bytes());`
`122`	`122`	`}`
`123`	`123`	`Ok(())`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`/// compile a filter useful for wallets`
`127`		`- pub fn script_filter(&mut self, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {`
	`127`	`+ pub fn script_filter(&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {`
`128`	`128`	`self.add_output_scripts();`
`129`		`- self.add_consumed_scripts(tx_accessor)`
	`129`	`+ self.add_consumed_scripts(height, tx_accessor)`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`/// compile a filter useful to find spent outputs`
`@@ -432,7 +432,7 @@ mod test {`
`432`	`432`	`}`
`433`	`433`
`434`	`434`	`impl ScriptAccessor for HashMap<OutPoint, Script> {`
`435`		`- fn get_scripts(&self, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {`
	`435`	`+ fn get_scripts(&self, _: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {`
`436`	`436`	`let mut result = Vec::new();`
`437`	`437`	`for coin in coins {`
`438`	`438`	`if let Some(ux) = self.get(&coin) {`
`@@ -483,7 +483,7 @@ mod test {`
`483`	`483`	`let mut constructed_filter = Cursor::new(Vec::new());`
`484`	`484`	`{`
`485`	`485`	`let mut writer = BlockFilterWriter::new(&mut constructed_filter, &block);`
`486`		`- writer.script_filter(txmap).unwrap();`
	`486`	`+ writer.script_filter(0, txmap).unwrap();`
`487`	`487`	`writer.finish().unwrap();`
`488`	`488`	`}`
`489`	`489`