feat: add indexer related rpc

Cargo.toml

@@ -51,6 +51,7 @@ members = [
     "pow",
     "benches",
     "resource",
+    "indexer",
 ]
 
 [profile.release]

ckb-bin/Cargo.toml

@@ -22,6 +22,7 @@ ckb-store = { path = "../store" }
 ckb-chain-spec = {path = "../spec"}
 ckb-notify = { path = "../notify"}
 ckb-miner = { path = "../miner" }
+ckb-indexer = { path = "../indexer" }
 ckb-db = { path = "../db" }
 ckb-pow = { path = "../pow" }
 ckb-network = { path = "../network"}

ckb-bin/src/subcommand/run.rs

@@ -133,7 +133,8 @@ pub fn run(args: RunArgs, version: Version) -> Result<(), ExitCode> {
             network_controller.clone(),
             chain_controller.clone(),
         )
-        .enable_alert(alert_verifier, alert_notifier, network_controller);
+        .enable_alert(alert_verifier, alert_notifier, network_controller)
+        .enable_indexer(&args.config.indexer_db, shared.clone());
     let io_handler = builder.build();
 
     let rpc_server = RpcServer::new(args.config.rpc, io_handler);

db/src/lib.rs

@@ -7,18 +7,17 @@ use failure::Fail;
 use std::ops::Range;
 use std::result;
 
-pub mod cachedb;
 pub mod config;
 pub mod memorydb;
 pub mod rocksdb;
 
-pub use crate::cachedb::CacheDB;
 pub use crate::config::DBConfig;
 pub use crate::memorydb::MemoryKeyValueDB;
 pub use crate::rocksdb::RocksDB;
 
 pub type Col = u32;
 pub type Result<T> = result::Result<T, Error>;
+pub type KeyValueIteratorItem = (Box<[u8]>, Box<[u8]>);
 
 #[derive(Clone, Debug, PartialEq, Eq, Fail)]
 pub enum Error {
@@ -36,6 +35,20 @@ pub trait KeyValueDB: Sync + Send {
         F: FnMut(&[u8], &[u8]) -> Result<()>;
 }
 
+pub trait IterableKeyValueDB: KeyValueDB {
+    fn iter<'a>(
+        &'a self,
+        col: Col,
+        from_key: &'a [u8],
+        direction: Direction,
+    ) -> Result<Box<Iterator<Item = KeyValueIteratorItem> + 'a>>;
+}
+
+pub enum Direction {
+    Forward,
+    Reverse,
+}
+
 pub trait DbBatch {
     fn insert(&mut self, col: Col, key: &[u8], value: &[u8]) -> Result<()>;
     fn delete(&mut self, col: Col, key: &[u8]) -> Result<()>;

db/src/rocksdb.rs

@@ -1,6 +1,12 @@
-use crate::{Col, DBConfig, DbBatch, Error, KeyValueDB, Result};
+use crate::{
+    Col, DBConfig, DbBatch, Direction, Error, IterableKeyValueDB, KeyValueDB, KeyValueIteratorItem,
+    Result,
+};
 use log::{info, warn};
-use rocksdb::{ColumnFamily, Error as RdbError, IteratorMode, Options, WriteBatch, DB};
+use rocksdb::{
+    ColumnFamily, Direction as RdbDirection, Error as RdbError, IteratorMode, Options, WriteBatch,
+    DB,
+};
 use std::ops::Range;
 use std::sync::Arc;
 
@@ -159,6 +165,26 @@ impl KeyValueDB for RocksDB {
     }
 }
 
+impl IterableKeyValueDB for RocksDB {
+    fn iter<'a>(
+        &'a self,
+        col: Col,
+        from_key: &'a [u8],
+        direction: Direction,
+    ) -> Result<Box<Iterator<Item = KeyValueIteratorItem> + 'a>> {
+        let cf = cf_handle(&self.inner, col)?;
+        let iter_direction = match direction {
+            Direction::Forward => RdbDirection::Forward,
+            Direction::Reverse => RdbDirection::Reverse,
+        };
+        let mode = IteratorMode::From(from_key, iter_direction);
+        self.inner
+            .iterator_cf(cf, mode)
+            .map(|iter| Box::new(iter) as Box<_>)
+            .map_err(Into::into)
+    }
+}
+
 pub struct RocksdbBatch {
     db: Arc<DB>,
     wb: WriteBatch,
@@ -318,4 +344,49 @@ mod tests {
         let _ = RocksDB::open_with_check(&config, 1, VERSION_KEY, VERSION_VALUE).unwrap();
         let _ = RocksDB::open_with_check(&config, 1, VERSION_KEY, VERSION_VALUE).unwrap();
     }
+
+    #[test]
+    fn iter() {
+        let db = setup_db("iter", 1);
+
+        let mut batch = db.batch().unwrap();
+        batch.insert(0, &[0, 0, 1], &[0, 0, 1]).unwrap();
+        batch.insert(0, &[0, 1, 1], &[0, 1, 1]).unwrap();
+        batch.insert(0, &[0, 1, 2], &[0, 1, 2]).unwrap();
+        batch.insert(0, &[0, 1, 3], &[0, 1, 3]).unwrap();
+        batch.insert(0, &[0, 2, 1], &[0, 2, 1]).unwrap();
+        batch.commit().unwrap();
+
+        let mut iter = db.iter(0, &[0, 1], Direction::Forward).unwrap();
+        assert_eq!(
+            (
+                vec![0, 1, 1].into_boxed_slice(),
+                vec![0, 1, 1].into_boxed_slice()
+            ),
+            iter.next().unwrap()
+        );
+        assert_eq!(
+            (
+                vec![0, 1, 2].into_boxed_slice(),
+                vec![0, 1, 2].into_boxed_slice()
+            ),
+            iter.next().unwrap()
+        );
+
+        let mut iter = db.iter(0, &[0, 2], Direction::Reverse).unwrap();
+        assert_eq!(
+            (
+                vec![0, 1, 3].into_boxed_slice(),
+                vec![0, 1, 3].into_boxed_slice()
+            ),
+            iter.next().unwrap()
+        );
+        assert_eq!(
+            (
+                vec![0, 1, 2].into_boxed_slice(),
+                vec![0, 1, 2].into_boxed_slice()
+            ),
+            iter.next().unwrap()
+        );
+    }
 }

indexer/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "ckb-indexer"
+version = "0.15.0-pre"
+license = "MIT"
+authors = ["Nervos Core Dev <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+ckb-core = { path = "../core" }
+ckb-db = { path = "../db" }
+ckb-notify = { path = "../notify" }
+ckb-shared = { path = "../shared" }
+ckb-store = { path = "../store" }
+ckb-traits = { path = "../traits" }
+jsonrpc-types = { path = "../util/jsonrpc-types" }
+numext-fixed-hash = { version = "0.1", features = ["support_rand", "support_heapsize", "support_serde"] }
+bincode = "1.1"
+serde = "1.0"
+serde_derive = "1.0"
+crossbeam-channel = "0.3"
+log = "0.4"
+
+[dev-dependencies]
+tempfile = "3.0"
+ckb-chain =  { path = "../chain" }
+ckb-chain-spec = { path = "../spec" }
+numext-fixed-uint = { version = "0.1", features = ["support_rand", "support_heapsize", "support_serde"] }

indexer/src/lib.rs

@@ -0,0 +1,5 @@
+mod store;
+mod types;
+
+pub use store::{DefaultIndexerStore, IndexerStore};
+pub use types::{CellTransaction, LiveCell, TransactionPoint};