new wallet storage and impl

storage/src/accumulator/mod.rs

@@ -17,7 +17,6 @@ use starcoin_accumulator::{
 };
 use std::io::Write;
 use std::mem::size_of;
-use std::sync::Arc;
 
 define_storage!(
     AccumulatorNodeStore,

storage/src/block/mod.rs

@@ -16,7 +16,6 @@ use serde::{Deserialize, Serialize};
 use starcoin_types::block::{Block, BlockBody, BlockHeader, BlockNumber, BlockState};
 use std::io::Write;
 use std::mem::size_of;
-use std::sync::Arc;
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub struct StorageBlock {

storage/src/block_info/mod.rs

@@ -9,7 +9,6 @@ use anyhow::Result;
 use crypto::HashValue;
 use scs::SCSCodec;
 use starcoin_types::block::BlockInfo;
-use std::sync::Arc;
 
 pub trait BlockInfoStore {
     fn save_block_info(&self, block_info: BlockInfo) -> Result<()>;

storage/src/contract_event.rs

@@ -9,7 +9,6 @@ use anyhow::Result;
 use crypto::HashValue;
 use scs::SCSCodec;
 use starcoin_types::contract_event::ContractEvent;
-use std::sync::Arc;
 
 define_storage!(
     ContractEventStorage,

storage/src/db_storage/mod.rs

@@ -13,49 +13,59 @@ use std::path::Path;
 
 pub struct DBStorage {
     db: DB,
+    cfs: Vec<ColumnFamilyName>,
 }
 
 impl DBStorage {
     pub fn new<P: AsRef<Path> + Clone>(db_root_path: P) -> Self {
         let path = db_root_path.as_ref().join("starcoindb");
-        Self::open(path, false).expect("Unable to open StarcoinDB")
+        Self::open_with_cfs(path, VEC_PREFIX_NAME.to_vec(), false)
+            .expect("Unable to open StarcoinDB")
     }
-    pub fn open(path: impl AsRef<Path>, readonly: bool) -> Result<Self> {
-        let column_families = VEC_PREFIX_NAME.to_vec();
+
+    pub fn open_with_cfs(
+        root_path: impl AsRef<Path>,
+        column_families: Vec<ColumnFamilyName>,
+        readonly: bool,
+    ) -> Result<Self> {
+        let path = root_path.as_ref();
+
         let cfs_set: HashSet<_> = column_families.iter().collect();
         {
             ensure!(
                 cfs_set.len() == column_families.len(),
                 "Duplicate column family name found.",
             );
         }
-        if Self::db_exists(path.as_ref()) {
-            let cf_vec = Self::list_cf(path.as_ref())?;
+        if Self::db_exists(path) {
+            let cf_vec = Self::list_cf(path)?;
             for cf in cf_vec {
                 if cf != DEFAULT_PREFIX_NAME && cfs_set.get(&cf.as_str()).is_none() {
                     error!(
                         "db path cf: {:?} is not equal,please clear dir: {:?}",
-                        path.as_ref(),
-                        cf
+                        path, cf
                     );
                     std::process::exit(100);
                 }
             }
         }
 
         let db = if readonly {
-            Self::open_readonly(path.as_ref(), column_families)?
+            Self::open_readonly(path, column_families.clone())?
         } else {
             let mut db_opts = rocksdb::Options::default();
             db_opts.create_if_missing(true);
             db_opts.create_missing_column_families(true);
             // For now we set the max total WAL size to be 1G. This config can be useful when column
             // families are updated at non-uniform frequencies.
             db_opts.set_max_total_wal_size(1 << 30);
-            Self::open_inner(&db_opts, path.as_ref(), column_families)?
+            Self::open_inner(&db_opts, path, column_families.clone())?
         };
 
-        Ok(DBStorage { db })
+        Ok(DBStorage {
+            db,
+            cfs: column_families,
+        })
     }
 
     fn open_inner(
@@ -88,7 +98,7 @@ impl DBStorage {
     }
 
     pub fn drop_cf(&mut self) -> Result<(), Error> {
-        for cf in &VEC_PREFIX_NAME.to_vec() {
+        for cf in self.cfs.clone() {
             self.db.drop_cf(cf)?;
         }
         Ok(())
@@ -97,7 +107,7 @@ impl DBStorage {
     /// Flushes all memtable data. This is only used for testing `get_approximate_sizes_cf` in unit
     /// tests.
     pub fn flush_all(&self) -> Result<()> {
-        for cf_name in VEC_PREFIX_NAME.to_vec() {
+        for cf_name in &self.cfs {
             let cf_handle = self.get_cf_handle(cf_name)?;
             self.db.flush_cf(cf_handle)?;
         }

storage/src/state_node/mod.rs

@@ -10,7 +10,6 @@ use crypto::HashValue;
 use forkable_jellyfish_merkle::node_type::Node;
 use starcoin_state_store_api::{StateNode, StateNodeStore};
 use std::collections::BTreeMap;
-use std::sync::Arc;
 
 define_storage!(StateStorage, HashValue, StateNode, STATE_NODE_PREFIX_NAME);
 

storage/src/storage_macros.rs

@@ -11,33 +11,33 @@ macro_rules! define_storage {
     ($storage_type: ident, $key_type: ty, $value_type: ty, $prefix_name: expr) => {
         #[derive(Clone)]
         pub struct $storage_type {
-            store: CodecStorage<$key_type, $value_type>,
+            store: $crate::storage::CodecStorage<$key_type, $value_type>,
         }
 
         impl $storage_type {
-            const PREFIX_NAME: $crate::ColumnFamilyName = $prefix_name;
-            pub fn new(instance: crate::storage::StorageInstance) -> Self {
-                let inner_storage = crate::storage::InnerStorage::new(instance, Self::PREFIX_NAME);
+            const PREFIX_NAME: $crate::storage::ColumnFamilyName = $prefix_name;
+            pub fn new(instance: $crate::storage::StorageInstance) -> Self {
+                let inner_storage = $crate::storage::InnerStorage::new(instance, Self::PREFIX_NAME);
                 Self {
-                    store: CodecStorage::new(Arc::new(inner_storage)),
+                    store: CodecStorage::new(std::sync::Arc::new(inner_storage)),
                 }
             }
-            pub fn put(&self, key: $key_type, value: $value_type) -> Result<()> {
+            pub fn put(&self, key: $key_type, value: $value_type) -> anyhow::Result<()> {
                 self.store.put(key, value)
             }
-            pub fn get(&self, key: $key_type) -> Result<Option<$value_type>> {
+            pub fn get(&self, key: $key_type) -> anyhow::Result<Option<$value_type>> {
                 self.store.get(key)
             }
-            pub fn remove(&self, key: $key_type) -> Result<()> {
+            pub fn remove(&self, key: $key_type) -> anyhow::Result<()> {
                 self.store.remove(key)
             }
-            pub fn write_batch(&self, batch: WriteBatch) -> Result<()> {
+            pub fn write_batch(&self, batch: WriteBatch) -> anyhow::Result<()> {
                 self.store.write_batch(batch)
             }
-            pub fn get_len(&self) -> Result<u64> {
+            pub fn get_len(&self) -> anyhow::Result<u64> {
                 self.store.get_len()
             }
-            pub fn keys(&self) -> Result<Vec<Vec<u8>>> {
+            pub fn keys(&self) -> anyhow::Result<Vec<Vec<u8>>> {
                 self.store.keys()
             }
         }

storage/src/tests/test_storage.rs

@@ -6,7 +6,10 @@ extern crate chrono;
 use crate::cache_storage::CacheStorage;
 use crate::db_storage::DBStorage;
 use crate::storage::{InnerStore, StorageInstance, ValueCodec, CACHE_NONE_OBJECT};
-use crate::{Storage, TransactionInfoStore, DEFAULT_PREFIX_NAME, TRANSACTION_INFO_PREFIX_NAME};
+use crate::{
+    Storage, TransactionInfoStore, DEFAULT_PREFIX_NAME, TRANSACTION_INFO_PREFIX_NAME,
+    VEC_PREFIX_NAME,
+};
 use anyhow::Result;
 use crypto::HashValue;
 use starcoin_types::transaction::TransactionInfo;
@@ -45,7 +48,7 @@ fn test_open_read_only() {
     let result = db.put(DEFAULT_PREFIX_NAME, key.to_vec(), value.to_vec());
     assert!(result.is_ok());
     let path = tmpdir.as_ref().join("starcoindb");
-    let db = DBStorage::open(path, true).unwrap();
+    let db = DBStorage::open_with_cfs(path, VEC_PREFIX_NAME.to_vec(), true).unwrap();
     let result = db.put(DEFAULT_PREFIX_NAME, key.to_vec(), value.to_vec());
     assert!(result.is_err());
     let result = db.get(DEFAULT_PREFIX_NAME, key.to_vec()).unwrap();

storage/src/transaction/mod.rs

@@ -10,7 +10,6 @@ use anyhow::Result;
 use crypto::HashValue;
 use scs::SCSCodec;
 use starcoin_types::transaction::Transaction;
-use std::sync::Arc;
 
 define_storage!(
     TransactionStorage,

storage/src/transaction_info/mod.rs

@@ -10,7 +10,6 @@ use anyhow::{bail, Error, Result};
 use crypto::HashValue;
 use scs::SCSCodec;
 use starcoin_types::transaction::TransactionInfo;
-use std::sync::Arc;
 
 define_storage!(
     TransactionInfoStorage,

wallet/api/Cargo.toml

@@ -15,6 +15,7 @@ starcoin-types = { path = "../../types"}
 starcoin-crypto = { path = "../../commons/crypto"}
 rand = "0.7.3"
 rand_core = { version = "0.5.1", default-features = false }
+futures = "0.3"
 
 [dev-dependencies]
 

wallet/api/src/lib.rs

@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod error;
+mod rich_wallet;
 mod service;
 mod store;
 mod types;
 mod wallet;
-
+pub use rich_wallet::*;
 pub use service::*;
 pub use store::*;
 pub use types::*;

wallet/api/src/mock/mock_wallet_service.rs

@@ -58,6 +58,9 @@ impl WalletAsyncService for MockWalletService {
             .wallet
             .unlock_account(address, password.as_str(), duration)?)
     }
+    async fn lock_account(self, address: AccountAddress) -> ServiceResult<()> {
+        Ok(self.wallet.lock_account(address)?)
+    }
 
     async fn import_account(
         self,

wallet/api/src/rich_wallet.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+use futures::Stream;
+use serde::Deserialize;
+use serde::Serialize;
+use starcoin_types::account_address::AccountAddress;
+use starcoin_types::account_config::token_code::TokenCode;
+use starcoin_types::contract_event::EventWithProof;
+use starcoin_types::event::EventKey;
+use starcoin_types::transaction::{RawUserTransaction, SignedUserTransaction, TransactionPayload};
+use std::time::Duration;
+
+pub trait ChainEventWatcher {
+    fn watch_event<S>(&self, key: EventKey) -> S
+    where
+        S: Stream<Item = EventWithProof>;
+}
+
+pub trait TransactionSubmitter {
+    fn submit_transaction(&self, txn: SignedUserTransaction) -> Result<()>;
+}
+
+pub trait RichWallet {
+    fn set_default_expiration_timeout(&mut self, timeout: Duration);
+    fn set_default_gas_price(&mut self, gas_price: u64);
+    fn set_default_gas_token(&mut self, token: TokenCode);
+
+    fn get_accepted_tokns(&self) -> Result<Vec<TokenCode>>;
+
+    fn build_transaction(
+        &self,
+        // if not specified, use default sender.
+        sender: Option<AccountAddress>,
+        payload: TransactionPayload,
+        max_gas_amount: u64,
+        // if not specified, uses default settings.
+        gas_unit_price: Option<u64>,
+        gas_token_code: Option<String>,
+        expiration_timestamp_secs: Option<u64>,
+    ) -> Result<RawUserTransaction>;
+
+    fn sign_transaction(
+        &self,
+        raw: RawUserTransaction,
+        address: Option<AccountAddress>,
+    ) -> Result<SignedUserTransaction>;
+    fn submit_txn(&mut self, txn: SignedUserTransaction) -> Result<()>;
+    fn get_next_available_seq_number(&self) -> Result<u64>;
+
+    // ...other functionality of origin wallets.
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct Setting {
+    default_expiration_timeout: u64,
+    default_gas_price: u64,
+    default_gas_token: TokenCode,
+}
+
+pub trait WalletStorageTrait {
+    fn save_default_settings(&self, setting: Setting) -> Result<()>;
+
+    fn save_accepted_token(&self, token: TokenCode) -> Result<()>;
+    fn contain_wallet(&self, address: AccountAddress) -> Result<bool>;
+}

wallet/api/src/service.rs

@@ -31,6 +31,7 @@ pub trait WalletAsyncService: Clone + std::marker::Unpin + Send + Sync {
         password: String,
         duration: std::time::Duration,
     ) -> ServiceResult<()>;
+    async fn lock_account(self, address: AccountAddress) -> ServiceResult<()>;
     async fn import_account(
         self,
         address: AccountAddress,

wallet/lib/Cargo.toml

@@ -13,11 +13,15 @@ actix = "0.10.0-alpha.3"
 actix-rt = "1.1"
 async-trait = "0.1"
 rand = "0.7.3"
+parking_lot = "0.9"
+serde = "1"
 rand_core = { version = "0.5.1", default-features = false }
-wallet-api = {path = "../api",package = "starcoin-wallet-api"}
-scs ={package= "starcoin-canonical-serialization", path = "../../commons/scs"}
+
+starcoin-wallet-api = {path = "../api",package = "starcoin-wallet-api"}
+starcoin-canonical-serialization ={package= "starcoin-canonical-serialization", path = "../../commons/scs"}
 starcoin-types = { path = "../../types"}
 starcoin-crypto = { path = "../../commons/crypto"}
 starcoin-decrypt = {path = "../../commons/decrypt"}
+starcoin-storage = {path = "../../storage"}
 [dev-dependencies]
 tempfile="3"

wallet/lib/src/file_wallet_store.rs

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{bail, Result};
-use scs::SCSCodec;
+use starcoin_canonical_serialization as scs;
+use starcoin_canonical_serialization::SCSCodec;
 use starcoin_types::account_address::AccountAddress;
+use starcoin_wallet_api::{WalletAccount, WalletStore};
 use std::fs::OpenOptions;
 use std::path::Path;
 use std::{
@@ -12,8 +14,6 @@ use std::{
     io::{Read, Write},
     path::PathBuf,
 };
-use wallet_api::WalletAccount;
-use wallet_api::WalletStore;
 
 pub const DEFAULT_ACCOUNT_FILE_NAME: &str = "account";
 

wallet/lib/src/keystore_wallet.rs

@@ -11,13 +11,13 @@ use starcoin_types::{
     account_address::{self, AccountAddress},
     transaction::{RawUserTransaction, SignedUserTransaction},
 };
+use starcoin_wallet_api::{error::WalletError, Wallet, WalletAccount, WalletStore};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::ops::Add;
 use std::sync::{Mutex, RwLock};
 use std::time::Duration;
 use std::time::Instant;
-use wallet_api::{error::WalletError, Wallet, WalletAccount, WalletStore};
 
 type KeyPair = starcoin_crypto::test_utils::KeyPair<Ed25519PrivateKey, Ed25519PublicKey>;
 pub type Result<T> = std::result::Result<T, WalletError>;