2018-06-22 11:08:06 +03:00
|
|
|
// Copyright 2018 The Grin Developers
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
use std::cell::RefCell;
|
|
|
|
use std::sync::Arc;
|
|
|
|
use std::{fs, path};
|
|
|
|
|
2018-07-02 02:23:24 +03:00
|
|
|
use failure::ResultExt;
|
2018-07-19 12:35:36 +03:00
|
|
|
use uuid::Uuid;
|
2018-06-22 11:08:06 +03:00
|
|
|
|
|
|
|
use keychain::{Identifier, Keychain};
|
2018-07-19 12:35:36 +03:00
|
|
|
use store::{self, option_to_not_found, to_key, u64_to_key};
|
2018-06-22 11:08:06 +03:00
|
|
|
|
|
|
|
use libwallet::types::*;
|
|
|
|
use libwallet::{internal, Error, ErrorKind};
|
|
|
|
use types::{WalletConfig, WalletSeed};
|
2018-08-17 14:15:06 +03:00
|
|
|
use util::secp::pedersen;
|
2018-06-22 11:08:06 +03:00
|
|
|
|
2018-07-09 20:01:19 +03:00
|
|
|
pub const DB_DIR: &'static str = "wallet_data";
|
2018-06-22 11:08:06 +03:00
|
|
|
|
2018-08-17 14:15:06 +03:00
|
|
|
const COMMITMENT_PREFIX: u8 = 'c' as u8;
|
2018-06-22 11:08:06 +03:00
|
|
|
const OUTPUT_PREFIX: u8 = 'o' as u8;
|
|
|
|
const DERIV_PREFIX: u8 = 'd' as u8;
|
2018-07-13 17:27:16 +03:00
|
|
|
const CONFIRMED_HEIGHT_PREFIX: u8 = 'c' as u8;
|
2018-07-19 12:35:36 +03:00
|
|
|
const TX_LOG_ENTRY_PREFIX: u8 = 't' as u8;
|
|
|
|
const TX_LOG_ID_PREFIX: u8 = 'i' as u8;
|
2018-06-22 11:08:06 +03:00
|
|
|
|
|
|
|
impl From<store::Error> for Error {
|
|
|
|
fn from(error: store::Error) -> Error {
|
2018-07-02 02:23:24 +03:00
|
|
|
Error::from(ErrorKind::Backend(format!("{:?}", error)))
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-09 20:01:19 +03:00
|
|
|
/// test to see if database files exist in the current directory. If so,
|
|
|
|
/// use a DB backend for all operations
|
|
|
|
pub fn wallet_db_exists(config: WalletConfig) -> bool {
|
|
|
|
let db_path = path::Path::new(&config.data_file_dir).join(DB_DIR);
|
|
|
|
db_path.exists()
|
|
|
|
}
|
|
|
|
|
2018-07-10 11:18:24 +03:00
|
|
|
pub struct LMDBBackend<C, K> {
|
2018-06-22 11:08:06 +03:00
|
|
|
db: store::Store,
|
|
|
|
config: WalletConfig,
|
|
|
|
/// passphrase: TODO better ways of dealing with this other than storing
|
|
|
|
passphrase: String,
|
|
|
|
/// Keychain
|
|
|
|
keychain: Option<K>,
|
2018-07-10 11:18:24 +03:00
|
|
|
/// client
|
|
|
|
client: C,
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
2018-07-10 11:18:24 +03:00
|
|
|
impl<C, K> LMDBBackend<C, K> {
|
|
|
|
pub fn new(config: WalletConfig, passphrase: &str, client: C) -> Result<Self, Error> {
|
2018-06-22 11:08:06 +03:00
|
|
|
let db_path = path::Path::new(&config.data_file_dir).join(DB_DIR);
|
|
|
|
fs::create_dir_all(&db_path).expect("Couldn't create wallet backend directory!");
|
|
|
|
|
|
|
|
let lmdb_env = Arc::new(store::new_env(db_path.to_str().unwrap().to_string()));
|
|
|
|
let db = store::Store::open(lmdb_env, DB_DIR);
|
|
|
|
Ok(LMDBBackend {
|
|
|
|
db,
|
|
|
|
config: config.clone(),
|
|
|
|
passphrase: String::from(passphrase),
|
|
|
|
keychain: None,
|
2018-07-10 11:18:24 +03:00
|
|
|
client: client,
|
2018-06-22 11:08:06 +03:00
|
|
|
})
|
|
|
|
}
|
2018-07-09 20:01:19 +03:00
|
|
|
|
|
|
|
/// Just test to see if database files exist in the current directory. If
|
|
|
|
/// so, use a DB backend for all operations
|
|
|
|
pub fn exists(config: WalletConfig) -> bool {
|
|
|
|
let db_path = path::Path::new(&config.data_file_dir).join(DB_DIR);
|
|
|
|
db_path.exists()
|
|
|
|
}
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
2018-07-10 11:18:24 +03:00
|
|
|
impl<C, K> WalletBackend<C, K> for LMDBBackend<C, K>
|
2018-06-22 11:08:06 +03:00
|
|
|
where
|
2018-07-10 11:18:24 +03:00
|
|
|
C: WalletClient,
|
2018-06-22 11:08:06 +03:00
|
|
|
K: Keychain,
|
|
|
|
{
|
|
|
|
/// Initialise with whatever stored credentials we have
|
|
|
|
fn open_with_credentials(&mut self) -> Result<(), Error> {
|
|
|
|
let wallet_seed = WalletSeed::from_file(&self.config)
|
|
|
|
.context(ErrorKind::CallbackImpl("Error opening wallet"))?;
|
|
|
|
let keychain = wallet_seed.derive_keychain(&self.passphrase);
|
|
|
|
self.keychain = Some(keychain.context(ErrorKind::CallbackImpl("Error deriving keychain"))?);
|
|
|
|
// Just blow up password for now after it's been used
|
|
|
|
self.passphrase = String::from("");
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Close wallet and remove any stored credentials (TBD)
|
|
|
|
fn close(&mut self) -> Result<(), Error> {
|
|
|
|
self.keychain = None;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the keychain being used
|
|
|
|
fn keychain(&mut self) -> &mut K {
|
|
|
|
self.keychain.as_mut().unwrap()
|
|
|
|
}
|
|
|
|
|
2018-07-10 11:18:24 +03:00
|
|
|
/// Return the client being used
|
|
|
|
fn client(&mut self) -> &mut C {
|
|
|
|
&mut self.client
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
fn get(&self, id: &Identifier) -> Result<OutputData, Error> {
|
|
|
|
let key = to_key(OUTPUT_PREFIX, &mut id.to_bytes().to_vec());
|
2018-07-01 01:36:38 +03:00
|
|
|
option_to_not_found(self.db.get_ser(&key), &format!("Key Id: {}", id)).map_err(|e| e.into())
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
2018-08-17 14:15:06 +03:00
|
|
|
fn get_commitment(&mut self, id: &Identifier) -> Result<pedersen::Commitment, Error> {
|
|
|
|
let key = to_key(COMMITMENT_PREFIX, &mut id.to_bytes().to_vec());
|
|
|
|
|
|
|
|
let res: Result<pedersen::Commitment, Error> =
|
|
|
|
option_to_not_found(self.db.get_ser(&key), &format!("Key Id: {}", id))
|
|
|
|
.map_err(|e| e.into());
|
|
|
|
|
|
|
|
// "cache hit" and return the commitment
|
|
|
|
if let Ok(commit) = res {
|
|
|
|
Ok(commit)
|
|
|
|
} else {
|
|
|
|
let out = self.get(id)?;
|
|
|
|
|
|
|
|
// Save the output data back to the db
|
|
|
|
// which builds and saves the associated commitment.
|
|
|
|
{
|
|
|
|
let mut batch = self.batch()?;
|
|
|
|
batch.save(out)?;
|
|
|
|
batch.commit()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now retrieve the saved commitment and return it.
|
|
|
|
option_to_not_found(self.db.get_ser(&key), &format!("Key Id: {}", id))
|
|
|
|
.map_err(|e| e.into())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
fn iter<'a>(&'a self) -> Box<Iterator<Item = OutputData> + 'a> {
|
|
|
|
Box::new(self.db.iter(&[OUTPUT_PREFIX]).unwrap())
|
|
|
|
}
|
|
|
|
|
2018-07-19 12:35:36 +03:00
|
|
|
fn get_tx_log_entry(&self, u: &Uuid) -> Result<Option<TxLogEntry>, Error> {
|
|
|
|
let key = to_key(TX_LOG_ENTRY_PREFIX, &mut u.as_bytes().to_vec());
|
|
|
|
self.db.get_ser(&key).map_err(|e| e.into())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn tx_log_iter<'a>(&'a self) -> Box<Iterator<Item = TxLogEntry> + 'a> {
|
|
|
|
Box::new(self.db.iter(&[TX_LOG_ENTRY_PREFIX]).unwrap())
|
|
|
|
}
|
|
|
|
|
2018-08-17 14:15:06 +03:00
|
|
|
fn batch<'a>(&'a mut self) -> Result<Box<WalletOutputBatch<K> + 'a>, Error> {
|
2018-06-22 11:08:06 +03:00
|
|
|
Ok(Box::new(Batch {
|
2018-07-13 17:27:16 +03:00
|
|
|
_store: self,
|
2018-06-22 11:08:06 +03:00
|
|
|
db: RefCell::new(Some(self.db.batch()?)),
|
2018-08-17 14:15:06 +03:00
|
|
|
keychain: self.keychain.clone(),
|
2018-06-22 11:08:06 +03:00
|
|
|
}))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn next_child<'a>(&mut self, root_key_id: Identifier) -> Result<u32, Error> {
|
2018-07-13 17:27:16 +03:00
|
|
|
let mut details = self.details(root_key_id.clone())?;
|
|
|
|
let mut batch = self.batch()?;
|
|
|
|
details.last_child_index = details.last_child_index + 1;
|
|
|
|
batch.save_details(root_key_id, details.clone())?;
|
|
|
|
batch.commit()?;
|
|
|
|
Ok(details.last_child_index + 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn details(&mut self, root_key_id: Identifier) -> Result<WalletDetails, Error> {
|
2018-06-22 11:08:06 +03:00
|
|
|
let batch = self.db.batch()?;
|
|
|
|
let deriv_key = to_key(DERIV_PREFIX, &mut root_key_id.to_bytes().to_vec());
|
|
|
|
let deriv_idx = match batch.get_ser(&deriv_key)? {
|
|
|
|
Some(idx) => idx,
|
|
|
|
None => 0,
|
|
|
|
};
|
2018-07-13 17:27:16 +03:00
|
|
|
let height_key = to_key(
|
|
|
|
CONFIRMED_HEIGHT_PREFIX,
|
|
|
|
&mut root_key_id.to_bytes().to_vec(),
|
|
|
|
);
|
|
|
|
let last_confirmed_height = match batch.get_ser(&height_key)? {
|
|
|
|
Some(h) => h,
|
|
|
|
None => 0,
|
|
|
|
};
|
|
|
|
Ok(WalletDetails {
|
|
|
|
last_child_index: deriv_idx,
|
|
|
|
last_confirmed_height: last_confirmed_height,
|
|
|
|
})
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fn restore(&mut self) -> Result<(), Error> {
|
|
|
|
internal::restore::restore(self).context(ErrorKind::Restore)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// An atomic batch in which all changes can be committed all at once or
|
|
|
|
/// discarded on error.
|
2018-07-10 11:18:24 +03:00
|
|
|
pub struct Batch<'a, C: 'a, K: 'a>
|
|
|
|
where
|
|
|
|
C: WalletClient,
|
|
|
|
K: Keychain,
|
|
|
|
{
|
2018-07-13 17:27:16 +03:00
|
|
|
_store: &'a LMDBBackend<C, K>,
|
2018-06-22 11:08:06 +03:00
|
|
|
db: RefCell<Option<store::Batch<'a>>>,
|
2018-08-17 14:15:06 +03:00
|
|
|
/// Keychain
|
|
|
|
keychain: Option<K>,
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(missing_docs)]
|
2018-08-17 14:15:06 +03:00
|
|
|
impl<'a, C, K> WalletOutputBatch<K> for Batch<'a, C, K>
|
2018-07-10 11:18:24 +03:00
|
|
|
where
|
|
|
|
C: WalletClient,
|
|
|
|
K: Keychain,
|
|
|
|
{
|
2018-08-17 14:15:06 +03:00
|
|
|
fn keychain(&mut self) -> &mut K {
|
|
|
|
self.keychain.as_mut().unwrap()
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
fn save(&mut self, out: OutputData) -> Result<(), Error> {
|
2018-08-17 14:15:06 +03:00
|
|
|
// Save the output data to the db.
|
|
|
|
{
|
|
|
|
let key = to_key(OUTPUT_PREFIX, &mut out.key_id.to_bytes().to_vec());
|
|
|
|
self.db.borrow().as_ref().unwrap().put_ser(&key, &out)?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save the associated output commitment.
|
|
|
|
{
|
|
|
|
let key = to_key(COMMITMENT_PREFIX, &mut out.key_id.to_bytes().to_vec());
|
|
|
|
let commit = self.keychain().commit(out.value, &out.key_id)?;
|
|
|
|
self.db.borrow().as_ref().unwrap().put_ser(&key, &commit)?;
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get(&self, id: &Identifier) -> Result<OutputData, Error> {
|
|
|
|
let key = to_key(OUTPUT_PREFIX, &mut id.to_bytes().to_vec());
|
2018-07-01 01:36:38 +03:00
|
|
|
option_to_not_found(
|
|
|
|
self.db.borrow().as_ref().unwrap().get_ser(&key),
|
|
|
|
&format!("Key ID: {}", id),
|
|
|
|
).map_err(|e| e.into())
|
2018-06-22 11:08:06 +03:00
|
|
|
}
|
|
|
|
|
2018-07-19 12:35:36 +03:00
|
|
|
fn iter(&self) -> Box<Iterator<Item = OutputData>> {
|
|
|
|
Box::new(
|
|
|
|
self.db
|
|
|
|
.borrow()
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.iter(&[OUTPUT_PREFIX])
|
|
|
|
.unwrap(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
fn delete(&mut self, id: &Identifier) -> Result<(), Error> {
|
2018-08-17 14:15:06 +03:00
|
|
|
// Delete the output data.
|
|
|
|
{
|
|
|
|
let key = to_key(OUTPUT_PREFIX, &mut id.to_bytes().to_vec());
|
|
|
|
let _ = self.db.borrow().as_ref().unwrap().delete(&key);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the associated output commitment.
|
|
|
|
{
|
|
|
|
let key = to_key(COMMITMENT_PREFIX, &mut id.to_bytes().to_vec());
|
|
|
|
let _ = self.db.borrow().as_ref().unwrap().delete(&key);
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-07-19 12:35:36 +03:00
|
|
|
fn next_tx_log_id(&mut self, root_key_id: Identifier) -> Result<u32, Error> {
|
|
|
|
let tx_id_key = to_key(TX_LOG_ID_PREFIX, &mut root_key_id.to_bytes().to_vec());
|
|
|
|
let mut last_tx_log_id = match self.db.borrow().as_ref().unwrap().get_ser(&tx_id_key)? {
|
|
|
|
Some(t) => t,
|
|
|
|
None => 0,
|
|
|
|
};
|
|
|
|
last_tx_log_id = last_tx_log_id + 1;
|
|
|
|
self.db
|
|
|
|
.borrow()
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.put_ser(&tx_id_key, &last_tx_log_id)?;
|
|
|
|
Ok(last_tx_log_id)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn tx_log_iter(&self) -> Box<Iterator<Item = TxLogEntry>> {
|
|
|
|
Box::new(
|
|
|
|
self.db
|
|
|
|
.borrow()
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.iter(&[TX_LOG_ENTRY_PREFIX])
|
|
|
|
.unwrap(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2018-07-13 17:27:16 +03:00
|
|
|
fn save_details(&mut self, root_key_id: Identifier, d: WalletDetails) -> Result<(), Error> {
|
|
|
|
let deriv_key = to_key(DERIV_PREFIX, &mut root_key_id.to_bytes().to_vec());
|
|
|
|
let height_key = to_key(
|
|
|
|
CONFIRMED_HEIGHT_PREFIX,
|
|
|
|
&mut root_key_id.to_bytes().to_vec(),
|
|
|
|
);
|
|
|
|
self.db
|
|
|
|
.borrow()
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.put_ser(&deriv_key, &d.last_child_index)?;
|
|
|
|
self.db
|
|
|
|
.borrow()
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.put_ser(&height_key, &d.last_confirmed_height)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-07-19 12:35:36 +03:00
|
|
|
fn save_tx_log_entry(&self, t: TxLogEntry) -> Result<(), Error> {
|
|
|
|
let tx_log_key = u64_to_key(TX_LOG_ENTRY_PREFIX, t.id as u64);
|
|
|
|
self.db.borrow().as_ref().unwrap().put_ser(&tx_log_key, &t)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-06-22 11:08:06 +03:00
|
|
|
fn lock_output(&mut self, out: &mut OutputData) -> Result<(), Error> {
|
|
|
|
out.lock();
|
|
|
|
self.save(out.clone())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn commit(&self) -> Result<(), Error> {
|
|
|
|
let db = self.db.replace(None);
|
|
|
|
db.unwrap().commit()?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|