Feat schema batch write v2

Cargo.toml

@@ -18,6 +18,7 @@ members = [
     "commons/forkable-jellyfish-merkle",
     "commons/time-service",
     "commons/infallible",
+    "commons/starcoin-temppath",
     "types",
     "types/uint",
     "genesis",
@@ -28,6 +29,7 @@ members = [
     "state/service",
     "config",
     "storage",
+    "storage/schemadb",
     "consensus",
     "consensus/cryptonight-rs",
     "testsuite",
@@ -131,6 +133,7 @@ default-members = [
     "commons/accumulator",
     "commons/forkable-jellyfish-merkle",
     "commons/infallible",
+    "commons/starcoin-temppath",
     "types",
     "types/uint",
     "genesis",
@@ -141,6 +144,7 @@ default-members = [
     "state/service",
     "config",
     "storage",
+    "storage/schemadb",
     "consensus",
     "consensus/cryptonight-rs",
     "testsuite",
@@ -475,6 +479,7 @@ starcoin-state-store-api = { path = "state/state-store-api" }
 starcoin-state-tree = { path = "state/state-tree" }
 starcoin-statedb = { path = "state/statedb" }
 starcoin-storage = { path = "storage" }
+starcoin-schemadb = { path = "storage/schemadb" }
 starcoin-stratum = { path = "stratum" }
 starcoin-sync = { path = "sync" }
 starcoin-sync-api = { path = "sync/api" }
@@ -489,6 +494,7 @@ starcoin-types = { path = "types" }
 starcoin-uint = { path = "types/uint" }
 starcoin-vm-runtime = { path = "vm/vm-runtime" }
 starcoin-vm-types = { path = "vm/types" }
+starcoin-temppath = { path = "commons/starcoin-temppath" }
 stdlib = { path = "vm/stdlib" }
 stest = { path = "commons/stest" }
 stest-macro = { path = "commons/stest/stest-macro" }

account/Cargo.toml

@@ -15,6 +15,7 @@ starcoin-decrypt = { workspace = true }
 starcoin-logger = { workspace = true }
 starcoin-storage = { workspace = true }
 starcoin-types = { workspace = true }
+starcoin-schemadb = { workspace = true }
 
 [dev-dependencies]
 hex = { workspace = true }

account/src/account.rs

@@ -4,19 +4,19 @@
 use crate::account_manager::gen_private_key;
 use crate::account_storage::AccountStorage;
 use anyhow::{format_err, Result};
-use starcoin_account_api::error::AccountError;
 use starcoin_account_api::{
-    AccountInfo, AccountPrivateKey, AccountPublicKey, AccountResult, Setting,
+    error::AccountError, AccountInfo, AccountPrivateKey, AccountPublicKey, AccountResult, Setting,
 };
 use starcoin_crypto::PrivateKey;
 use starcoin_logger::prelude::*;
-use starcoin_storage::storage::StorageInstance;
-use starcoin_types::account_address;
-use starcoin_types::account_address::AccountAddress;
-use starcoin_types::genesis_config::ChainId;
-use starcoin_types::sign_message::{SignedMessage, SigningMessage};
-use starcoin_types::transaction::authenticator::AuthenticationKey;
-use starcoin_types::transaction::{RawUserTransaction, SignedUserTransaction};
+use starcoin_types::{
+    account_address,
+    account_address::AccountAddress,
+    genesis_config::ChainId,
+    sign_message::{SignedMessage, SigningMessage},
+    transaction::authenticator::AuthenticationKey,
+    transaction::{RawUserTransaction, SignedUserTransaction},
+};
 
 pub struct Account {
     addr: AccountAddress,
@@ -172,7 +172,7 @@ impl Account {
         let private_key = gen_private_key();
         let public_key = private_key.public_key();
         let address = account_address::from_public_key(&public_key);
-        let storage = AccountStorage::new(StorageInstance::new_cache_instance());
+        let storage = AccountStorage::mock();
         Self::create(address, private_key.into(), "".to_string(), storage).map_err(|e| e.into())
     }
 }

account/src/account_manager.rs

@@ -148,6 +148,7 @@ impl AccountManager {
             None => Account::create_readonly(address, public_key, self.store.clone())?,
         };
 
+        // todo: merge following single writes to one schema-batch-write: add_address + set_default
         self.store.add_address(*account.address())?;
 
         // if it's the first address, set it default.
@@ -195,7 +196,8 @@ impl AccountManager {
                     "Can not find account_info by address:{}, clear it from address list.",
                     account
                 );
-                self.store.remove_address(account)?;
+                // todo: merge single writes to one batch-write
+                self.store.remove_address_from_all(account)?;
             }
         }
         Ok(res)
@@ -254,6 +256,7 @@ impl AccountManager {
         }
     }
 
+    // todo: merge single writes to one batch-write
     pub fn set_default_account(&self, address: AccountAddress) -> AccountResult<AccountInfo> {
         let mut account_info = self
             .account_info(address)?

account/src/account_schemadb/accepted_token.rs

@@ -0,0 +1,42 @@
+use anyhow::Result;
+use bcs_ext::BCSCodec;
+use serde::{Deserialize, Serialize};
+use starcoin_schemadb::{
+    define_schema,
+    schema::{KeyCodec, ValueCodec},
+    ColumnFamilyName,
+};
+use starcoin_types::account_address::AccountAddress;
+use starcoin_types::account_config::token_code::TokenCode;
+
+pub const ACCEPTED_TOKEN_PREFIX_NAME: ColumnFamilyName = "accepted_token";
+
+define_schema!(
+    AcceptedToken,
+    AccountAddress,
+    AcceptedTokens,
+    ACCEPTED_TOKEN_PREFIX_NAME
+);
+
+impl KeyCodec<AcceptedToken> for AccountAddress {
+    fn encode_key(&self) -> Result<Vec<u8>> {
+        Ok(self.to_vec())
+    }
+
+    fn decode_key(data: &[u8]) -> Result<Self> {
+        AccountAddress::try_from(data).map_err(Into::into)
+    }
+}
+
+#[derive(Default, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub struct AcceptedTokens(pub Vec<TokenCode>);
+
+impl ValueCodec<AcceptedToken> for AcceptedTokens {
+    fn encode_value(&self) -> Result<Vec<u8>> {
+        self.0.encode()
+    }
+
+    fn decode_value(data: &[u8]) -> Result<Self> {
+        <Vec<TokenCode>>::decode(data).map(AcceptedTokens)
+    }
+}

account/src/account_schemadb/global_setting.rs

@@ -0,0 +1,50 @@
+use anyhow::Result;
+use bcs_ext::BCSCodec;
+use serde::{Deserialize, Serialize};
+use starcoin_schemadb::{
+    define_schema,
+    schema::{KeyCodec, ValueCodec},
+    ColumnFamilyName,
+};
+use starcoin_types::account_address::AccountAddress;
+
+pub const GLOBAL_PREFIX_NAME: ColumnFamilyName = "global";
+
+define_schema!(
+    GlobalSetting,
+    GlobalSettingKey,
+    GlobalValue,
+    GLOBAL_PREFIX_NAME
+);
+
+#[derive(Hash, Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub enum GlobalSettingKey {
+    DefaultAddress,
+    /// FIXME: once db support iter, remove this.
+    AllAddresses,
+}
+
+#[derive(Default, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GlobalValue {
+    pub(crate) addresses: Vec<AccountAddress>,
+}
+
+impl KeyCodec<GlobalSetting> for GlobalSettingKey {
+    fn encode_key(&self) -> Result<Vec<u8>> {
+        self.encode()
+    }
+
+    fn decode_key(data: &[u8]) -> Result<Self> {
+        GlobalSettingKey::decode(data)
+    }
+}
+
+impl ValueCodec<GlobalSetting> for GlobalValue {
+    fn encode_value(&self) -> Result<Vec<u8>> {
+        self.addresses.encode()
+    }
+
+    fn decode_value(data: &[u8]) -> Result<Self> {
+        <Vec<AccountAddress>>::decode(data).map(|addresses| GlobalValue { addresses })
+    }
+}

account/src/account_schemadb/mod.rs

@@ -0,0 +1,78 @@
+use anyhow::Result;
+use starcoin_schemadb::schema::Schema;
+use starcoin_storage::cache_storage::GCacheStorage;
+use std::sync::Arc;
+
+mod accepted_token;
+mod global_setting;
+mod private_key;
+mod public_key;
+mod setting;
+
+pub(crate) use accepted_token::*;
+pub(crate) use global_setting::*;
+pub(crate) use private_key::*;
+pub(crate) use public_key::*;
+pub(crate) use setting::*;
+use starcoin_schemadb::{db::DBStorage as DB, SchemaBatch};
+
+#[derive(Clone)]
+pub(super) struct AccountStore<S: Schema> {
+    cache: Arc<GCacheStorage<S::Key, S::Value>>,
+    db: Option<Arc<DB>>,
+}
+
+impl<S: Schema> AccountStore<S> {
+    // create an memory-based store
+    pub fn new() -> Self {
+        Self {
+            cache: Arc::new(GCacheStorage::<S::Key, S::Value>::new(None)),
+            db: None,
+        }
+    }
+    pub fn new_with_db(db: &Arc<DB>) -> Self {
+        Self {
+            cache: Arc::new(GCacheStorage::<S::Key, S::Value>::new(None)),
+            db: Some(Arc::clone(db)),
+        }
+    }
+
+    pub fn get(&self, key: &S::Key) -> Result<Option<S::Value>> {
+        self.cache
+            .get_inner(key)
+            .map(|val| Ok(Some(val)))
+            .unwrap_or_else(|| {
+                self.db
+                    .as_ref()
+                    .map_or_else(|| Ok(None), |db| db.get::<S>(key))
+            })
+    }
+
+    pub fn put(&self, key: S::Key, value: S::Value) -> Result<()> {
+        self.db
+            .as_ref()
+            .map_or_else(|| Ok(()), |db| db.put::<S>(&key, &value))
+            .map(|_| {
+                self.cache.put_inner(key, value);
+            })
+    }
+
+    pub fn remove(&self, key: &S::Key) -> Result<()> {
+        self.db
+            .as_ref()
+            .map_or_else(|| Ok(()), |db| db.remove::<S>(key))
+            .map(|_| {
+                self.cache.remove_inner(key);
+            })
+    }
+
+    pub fn put_batch(&self, key: S::Key, value: S::Value, batch: &SchemaBatch) -> Result<()> {
+        batch.put::<S>(&key, &value)?;
+        self.put(key, value)
+    }
+
+    pub fn remove_batch(&self, key: &S::Key, batch: &SchemaBatch) -> Result<()> {
+        batch.delete::<S>(key)?;
+        self.remove(key)
+    }
+}

account/src/account_schemadb/private_key.rs

@@ -0,0 +1,44 @@
+use anyhow::Result;
+use starcoin_schemadb::{
+    define_schema,
+    schema::{KeyCodec, ValueCodec},
+    ColumnFamilyName,
+};
+use starcoin_types::account_address::AccountAddress;
+
+pub const ENCRYPTED_PRIVATE_KEY_PREFIX_NAME: ColumnFamilyName = "encrypted_private_key";
+
+define_schema!(
+    PrivateKey,
+    AccountAddress,
+    EncryptedPrivateKey,
+    ENCRYPTED_PRIVATE_KEY_PREFIX_NAME
+);
+
+impl KeyCodec<PrivateKey> for AccountAddress {
+    fn encode_key(&self) -> Result<Vec<u8>> {
+        Ok(self.to_vec())
+    }
+
+    fn decode_key(data: &[u8]) -> Result<Self> {
+        AccountAddress::try_from(data).map_err(Into::into)
+    }
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct EncryptedPrivateKey(pub Vec<u8>);
+impl From<Vec<u8>> for EncryptedPrivateKey {
+    fn from(s: Vec<u8>) -> Self {
+        Self(s)
+    }
+}
+
+impl ValueCodec<PrivateKey> for EncryptedPrivateKey {
+    fn encode_value(&self) -> Result<Vec<u8>> {
+        Ok(self.0.clone())
+    }
+
+    fn decode_value(data: &[u8]) -> Result<Self> {
+        Ok(EncryptedPrivateKey(data.to_vec()))
+    }
+}