1320 lines
44 KiB
Rust
1320 lines
44 KiB
Rust
use crate::chain::{Nf, NfRef};
|
|
use crate::contact::Contact;
|
|
use crate::prices::Quote;
|
|
use crate::taddr::{derive_tkeys, TBalance};
|
|
use crate::transaction::TransactionInfo;
|
|
use crate::commitment::{CTree, Witness};
|
|
use rusqlite::Error::QueryReturnedNoRows;
|
|
use rusqlite::{params, Connection, OptionalExtension, Transaction};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_with::serde_as;
|
|
use std::collections::HashMap;
|
|
use std::convert::TryInto;
|
|
use zcash_client_backend::encoding::decode_extended_full_viewing_key;
|
|
use zcash_params::coin::{CoinType, get_coin_chain, get_coin_id};
|
|
use zcash_primitives::consensus::{Network, NetworkUpgrade, Parameters};
|
|
use zcash_primitives::merkle_tree::IncrementalWitness;
|
|
use zcash_primitives::sapling::{Diversifier, Node, Note, Rseed, SaplingIvk};
|
|
use zcash_primitives::zip32::{DiversifierIndex, ExtendedFullViewingKey};
|
|
use crate::sync;
|
|
|
|
mod migration;
|
|
|
|
#[allow(dead_code)]
|
|
pub const DEFAULT_DB_PATH: &str = "zec.db";
|
|
|
|
#[derive(Clone)]
|
|
pub struct DbAdapterBuilder {
|
|
pub coin_type: CoinType,
|
|
pub db_path: String,
|
|
}
|
|
|
|
pub struct DbAdapter {
|
|
pub coin_type: CoinType,
|
|
pub connection: Connection,
|
|
pub db_path: String,
|
|
}
|
|
|
|
pub struct ReceivedNote {
|
|
pub account: u32,
|
|
pub height: u32,
|
|
pub output_index: u32,
|
|
pub diversifier: Vec<u8>,
|
|
pub value: u64,
|
|
pub rcm: Vec<u8>,
|
|
pub nf: Vec<u8>,
|
|
pub rho: Option<Vec<u8>>,
|
|
pub spent: Option<u32>,
|
|
}
|
|
|
|
pub struct ReceivedNoteShort {
|
|
pub id: u32,
|
|
pub account: u32,
|
|
pub nf: Nf,
|
|
pub value: u64,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct SpendableNote {
|
|
pub id: u32,
|
|
pub note: Note,
|
|
pub diversifier: Diversifier,
|
|
pub witness: IncrementalWitness<Node>,
|
|
}
|
|
|
|
pub struct AccountViewKey {
|
|
pub fvk: ExtendedFullViewingKey,
|
|
pub ivk: SaplingIvk,
|
|
pub viewonly: bool,
|
|
}
|
|
|
|
impl AccountViewKey {
|
|
pub fn from_fvk(fvk: &ExtendedFullViewingKey) -> AccountViewKey {
|
|
AccountViewKey {
|
|
fvk: fvk.clone(),
|
|
ivk: fvk.fvk.vk.ivk(),
|
|
viewonly: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct AccountBackup {
|
|
pub coin: u8,
|
|
pub name: String,
|
|
pub seed: Option<String>,
|
|
pub index: u32,
|
|
pub z_sk: Option<String>,
|
|
pub ivk: String,
|
|
pub z_addr: String,
|
|
pub t_sk: Option<String>,
|
|
pub t_addr: Option<String>,
|
|
}
|
|
|
|
pub fn wrap_query_no_rows(name: &'static str) -> impl Fn(rusqlite::Error) -> anyhow::Error {
|
|
move |err: rusqlite::Error| match err {
|
|
QueryReturnedNoRows => anyhow::anyhow!("Query {} returned no rows", name),
|
|
other => anyhow::anyhow!(other.to_string()),
|
|
}
|
|
}
|
|
|
|
impl DbAdapterBuilder {
|
|
pub fn build(&self) -> anyhow::Result<DbAdapter> {
|
|
DbAdapter::new(
|
|
self.coin_type,
|
|
&self.db_path,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl DbAdapter {
|
|
pub fn new(coin_type: CoinType, db_path: &str) -> anyhow::Result<DbAdapter> {
|
|
let connection = Connection::open(db_path)?;
|
|
connection.query_row("PRAGMA journal_mode = WAL", [], |_| Ok(()))?;
|
|
connection.execute("PRAGMA synchronous = NORMAL", [])?;
|
|
Ok(DbAdapter {
|
|
coin_type,
|
|
connection,
|
|
db_path: db_path.to_owned(),
|
|
})
|
|
}
|
|
|
|
pub fn disable_wal(db_path: &str) -> anyhow::Result<()> {
|
|
let connection = Connection::open(db_path)?;
|
|
connection.query_row("PRAGMA journal_mode = OFF", [], |_| Ok(()))?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn begin_transaction(&mut self) -> anyhow::Result<Transaction> {
|
|
let tx = self.connection.transaction()?;
|
|
Ok(tx)
|
|
}
|
|
//
|
|
// pub fn commit(&self) -> anyhow::Result<()> {
|
|
// self.connection.execute("COMMIT", [])?;
|
|
// Ok(())
|
|
// }
|
|
//
|
|
pub fn init_db(&mut self) -> anyhow::Result<()> {
|
|
migration::init_db(&self.connection)?;
|
|
self.delete_incomplete_scan()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn reset_db(&self) -> anyhow::Result<()> {
|
|
migration::reset_db(&self.connection)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_account(
|
|
&self,
|
|
name: &str,
|
|
seed: Option<&str>,
|
|
index: u32,
|
|
sk: Option<&str>,
|
|
ivk: &str,
|
|
address: &str,
|
|
) -> anyhow::Result<(u32, bool)> {
|
|
let mut statement = self
|
|
.connection
|
|
.prepare("SELECT id_account FROM accounts WHERE ivk = ?1")?;
|
|
let exists = statement.exists(params![ivk])?;
|
|
self.connection.execute(
|
|
"INSERT INTO accounts(name, seed, aindex, sk, ivk, address) VALUES (?1, ?2, ?3, ?4, ?5, ?6)
|
|
ON CONFLICT DO NOTHING",
|
|
params![name, seed, index, sk, ivk, address],
|
|
)?;
|
|
let id_account: u32 = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT id_account FROM accounts WHERE ivk = ?1",
|
|
params![ivk],
|
|
|row| row.get(0),
|
|
)
|
|
.map_err(wrap_query_no_rows("store_account/id_account"))?;
|
|
Ok((id_account, exists))
|
|
}
|
|
|
|
pub fn next_account_id(&self, seed: &str) -> anyhow::Result<u32> {
|
|
let index = self.connection.query_row(
|
|
"SELECT MAX(aindex) FROM accounts WHERE seed = ?1",
|
|
[seed],
|
|
|row| {
|
|
let aindex: Option<i32> = row.get(0)?;
|
|
Ok(aindex.unwrap_or(-1))
|
|
},
|
|
)? + 1;
|
|
Ok(index as u32)
|
|
}
|
|
|
|
pub fn store_transparent_key(
|
|
&self,
|
|
id_account: u32,
|
|
sk: &str,
|
|
addr: &str,
|
|
) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"UPDATE taddrs SET sk = ?1, address = ?2 WHERE account = ?3",
|
|
params![sk, addr, id_account],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_fvks(&self) -> anyhow::Result<HashMap<u32, AccountViewKey>> {
|
|
let mut statement = self
|
|
.connection
|
|
.prepare("SELECT id_account, ivk, sk FROM accounts")?;
|
|
let rows = statement.query_map([], |row| {
|
|
let account: u32 = row.get(0)?;
|
|
let ivk: String = row.get(1)?;
|
|
let sk: Option<String> = row.get(2)?;
|
|
let fvk = decode_extended_full_viewing_key(
|
|
self.network().hrp_sapling_extended_full_viewing_key(),
|
|
&ivk,
|
|
)
|
|
.unwrap()
|
|
.unwrap();
|
|
let ivk = fvk.fvk.vk.ivk();
|
|
Ok((
|
|
account,
|
|
AccountViewKey {
|
|
fvk,
|
|
ivk,
|
|
viewonly: sk.is_none(),
|
|
},
|
|
))
|
|
})?;
|
|
let mut fvks: HashMap<u32, AccountViewKey> = HashMap::new();
|
|
for r in rows {
|
|
let row = r?;
|
|
fvks.insert(row.0, row.1);
|
|
}
|
|
Ok(fvks)
|
|
}
|
|
|
|
pub fn trim_to_height(&mut self, height: u32) -> anyhow::Result<u32> {
|
|
// snap height to an existing checkpoint
|
|
let height = self.connection.query_row(
|
|
"SELECT MAX(height) from blocks WHERE height <= ?1",
|
|
params![height],
|
|
|row| {
|
|
let height: Option<u32> = row.get(0)?;
|
|
Ok(height)
|
|
},
|
|
)?;
|
|
let height = height.unwrap_or(0);
|
|
log::info!("Rewind to height: {}", height);
|
|
|
|
let tx = self.connection.transaction()?;
|
|
tx.execute("DELETE FROM blocks WHERE height > ?1", params![height])?;
|
|
tx.execute(
|
|
"DELETE FROM sapling_witnesses WHERE height > ?1",
|
|
params![height],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM orchard_witnesses WHERE height > ?1",
|
|
params![height],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM received_notes WHERE height > ?1",
|
|
params![height],
|
|
)?;
|
|
tx.execute(
|
|
"UPDATE received_notes SET spent = NULL WHERE spent > ?1",
|
|
params![height],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM transactions WHERE height > ?1",
|
|
params![height],
|
|
)?;
|
|
tx.execute("DELETE FROM messages WHERE height > ?1", params![height])?;
|
|
tx.commit()?;
|
|
|
|
Ok(height)
|
|
}
|
|
|
|
pub fn get_txhash(&self, id_tx: u32) -> anyhow::Result<(u32, u32, u32, Vec<u8>, String)> {
|
|
let (account, height, timestamp, tx_hash, ivk) = self.connection.query_row(
|
|
"SELECT account, height, timestamp, txid, ivk FROM transactions t, accounts a WHERE id_tx = ?1 AND t.account = a.id_account",
|
|
params![id_tx],
|
|
|row| {
|
|
let account: u32 = row.get(0)?;
|
|
let height: u32 = row.get(1)?;
|
|
let timestamp: u32 = row.get(2)?;
|
|
let tx_hash: Vec<u8> = row.get(3)?;
|
|
let ivk: String = row.get(4)?;
|
|
Ok((account, height, timestamp, tx_hash, ivk))
|
|
},
|
|
).map_err(wrap_query_no_rows("get_txhash"))?;
|
|
Ok((account, height, timestamp, tx_hash, ivk))
|
|
}
|
|
|
|
pub fn store_block(
|
|
connection: &Connection,
|
|
height: u32,
|
|
hash: &[u8],
|
|
timestamp: u32,
|
|
sapling_tree: &CTree,
|
|
orchard_tree: Option<&CTree>,
|
|
) -> anyhow::Result<()> {
|
|
log::debug!("+block");
|
|
let mut sapling_bb: Vec<u8> = vec![];
|
|
sapling_tree.write(&mut sapling_bb)?;
|
|
let orchard_bb = orchard_tree.map(|tree| {
|
|
let mut bb: Vec<u8> = vec![];
|
|
tree.write(&mut bb).unwrap();
|
|
bb
|
|
});
|
|
connection.execute(
|
|
"INSERT INTO blocks(height, hash, timestamp, sapling_tree, orchard_tree)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT DO NOTHING",
|
|
params![height, hash, timestamp, &sapling_bb, orchard_bb],
|
|
)?;
|
|
log::debug!("-block");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_block2(
|
|
height: u32,
|
|
hash: &[u8],
|
|
timestamp: u32,
|
|
sapling_tree: &sync::CTree,
|
|
orchard_tree: Option<&sync::CTree>,
|
|
connection: &Connection,
|
|
) -> anyhow::Result<()> {
|
|
log::debug!("+block");
|
|
let mut sapling_bb: Vec<u8> = vec![];
|
|
sapling_tree.write(&mut sapling_bb)?;
|
|
let orchard_bb = orchard_tree.map(|tree| {
|
|
let mut bb: Vec<u8> = vec![];
|
|
tree.write(&mut bb).unwrap();
|
|
bb
|
|
});
|
|
connection.execute(
|
|
"INSERT INTO blocks(height, hash, timestamp, sapling_tree, orchard_tree)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT DO NOTHING",
|
|
params![height, hash, timestamp, &sapling_bb, orchard_bb],
|
|
)?;
|
|
log::debug!("-block");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_transaction(
|
|
txid: &[u8],
|
|
account: u32,
|
|
height: u32,
|
|
timestamp: u32,
|
|
tx_index: u32,
|
|
db_tx: &Transaction,
|
|
) -> anyhow::Result<u32> {
|
|
log::debug!("+transaction");
|
|
db_tx.execute(
|
|
"INSERT INTO transactions(account, txid, height, timestamp, tx_index, value)
|
|
VALUES (?1, ?2, ?3, ?4, ?5, 0)
|
|
ON CONFLICT DO NOTHING",
|
|
params![account, txid, height, timestamp, tx_index],
|
|
)?;
|
|
let id_tx: u32 = db_tx
|
|
.query_row(
|
|
"SELECT id_tx FROM transactions WHERE account = ?1 AND txid = ?2",
|
|
params![account, txid],
|
|
|row| row.get(0),
|
|
)
|
|
.map_err(wrap_query_no_rows("store_transaction/id_tx"))?;
|
|
log::debug!("-transaction {}", id_tx);
|
|
Ok(id_tx)
|
|
}
|
|
|
|
pub fn store_received_note(
|
|
note: &ReceivedNote,
|
|
id_tx: u32,
|
|
position: usize,
|
|
db_tx: &Transaction,
|
|
) -> anyhow::Result<u32> {
|
|
log::debug!("+received_note {}", id_tx);
|
|
db_tx.execute("INSERT INTO received_notes(account, tx, height, position, output_index, diversifier, value, rcm, rho, nf, spent)
|
|
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)
|
|
ON CONFLICT DO NOTHING", params![note.account, id_tx, note.height, position as u32, note.output_index, note.diversifier, note.value as i64, note.rcm, note.rho, note.nf, note.spent])?;
|
|
let id_note: u32 = db_tx
|
|
.query_row(
|
|
"SELECT id_note FROM received_notes WHERE tx = ?1 AND output_index = ?2",
|
|
params![id_tx, note.output_index],
|
|
|row| row.get(0),
|
|
)
|
|
.map_err(wrap_query_no_rows("store_received_note/id_note"))?;
|
|
log::debug!("-received_note");
|
|
Ok(id_note)
|
|
}
|
|
|
|
// TODO: Depends on the type of witness
|
|
pub fn store_witnesses(
|
|
connection: &Connection,
|
|
witness: &Witness,
|
|
height: u32,
|
|
id_note: u32,
|
|
) -> anyhow::Result<()> {
|
|
log::debug!("+witnesses");
|
|
let mut bb: Vec<u8> = vec![];
|
|
witness.write(&mut bb)?;
|
|
connection.execute(
|
|
"INSERT INTO sapling_witnesses(note, height, witness) VALUES (?1, ?2, ?3)
|
|
ON CONFLICT DO NOTHING",
|
|
params![id_note, height, bb],
|
|
)?;
|
|
log::debug!("-witnesses");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_witness(
|
|
witness: &sync::Witness,
|
|
height: u32,
|
|
id_note: u32,
|
|
connection: &Connection,
|
|
shielded_pool: &str
|
|
) -> anyhow::Result<()> {
|
|
log::debug!("+store_witness");
|
|
let mut bb: Vec<u8> = vec![];
|
|
witness.write(&mut bb)?;
|
|
connection.execute(
|
|
&format!("INSERT INTO {}_witnesses(note, height, witness) VALUES (?1, ?2, ?3)
|
|
ON CONFLICT DO NOTHING", shielded_pool),
|
|
params![id_note, height, bb],
|
|
)?;
|
|
log::debug!("-store_witness");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_tx_metadata(&self, id_tx: u32, tx_info: &TransactionInfo) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"UPDATE transactions SET address = ?1, memo = ?2 WHERE id_tx = ?3",
|
|
params![tx_info.address, &tx_info.memo, id_tx],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn add_value(id_tx: u32, value: i64, db_tx: &Transaction) -> anyhow::Result<()> {
|
|
db_tx.execute(
|
|
"UPDATE transactions SET value = value + ?2 WHERE id_tx = ?1",
|
|
params![id_tx, value],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_received_note_value(nf: &Nf, db_tx: &Transaction) -> anyhow::Result<(u32, i64)> {
|
|
let (account, value) = db_tx
|
|
.query_row(
|
|
"SELECT account, value FROM received_notes WHERE nf = ?1",
|
|
params![nf.0.to_vec()],
|
|
|row| {
|
|
let account: u32 = row.get(0)?;
|
|
let value: i64 = row.get(1)?;
|
|
Ok((account, value))
|
|
},
|
|
)
|
|
.map_err(wrap_query_no_rows("get_received_note_value"))?;
|
|
Ok((account, value))
|
|
}
|
|
|
|
pub fn get_balance(&self, account: u32) -> anyhow::Result<u64> {
|
|
let balance: Option<i64> = self.connection.query_row(
|
|
"SELECT SUM(value) FROM received_notes WHERE (spent IS NULL OR spent = 0) AND account = ?1",
|
|
params![account],
|
|
|row| row.get(0),
|
|
)?;
|
|
Ok(balance.unwrap_or(0) as u64)
|
|
}
|
|
|
|
pub fn get_last_sync_height(&self) -> anyhow::Result<Option<u32>> {
|
|
let height: Option<u32> = self
|
|
.connection
|
|
.query_row("SELECT MAX(height) FROM blocks", [], |row| row.get(0))
|
|
.map_err(wrap_query_no_rows(""))?;
|
|
Ok(height)
|
|
}
|
|
|
|
pub fn get_db_height(&self) -> anyhow::Result<u32> {
|
|
let height: u32 = self.get_last_sync_height()?.unwrap_or_else(|| {
|
|
self.network()
|
|
.activation_height(NetworkUpgrade::Sapling)
|
|
.unwrap()
|
|
.into()
|
|
});
|
|
Ok(height)
|
|
}
|
|
|
|
pub fn get_db_hash(&self, height: u32) -> anyhow::Result<Option<[u8; 32]>> {
|
|
let hash: Option<Vec<u8>> = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT hash FROM blocks WHERE height = ?1",
|
|
params![height],
|
|
|row| row.get(0),
|
|
)
|
|
.optional()?;
|
|
Ok(hash.map(|h| {
|
|
let mut hash = [0u8; 32];
|
|
hash.copy_from_slice(&h);
|
|
hash
|
|
}))
|
|
}
|
|
|
|
pub fn get_tree(&self) -> anyhow::Result<(CTree, Vec<Witness>)> {
|
|
todo!()
|
|
}
|
|
|
|
pub fn get_tree_by_name(&self, shielded_pool: &str) -> anyhow::Result<(sync::CTree, Vec<sync::Witness>)> {
|
|
let res = self.connection.query_row(
|
|
&format!("SELECT height, {}_tree FROM blocks WHERE height = (SELECT MAX(height) FROM blocks)", shielded_pool),
|
|
[], |row| {
|
|
let height: u32 = row.get(0)?;
|
|
let tree: Vec<u8> = row.get(1)?;
|
|
Ok((height, tree))
|
|
}).optional()?;
|
|
Ok(match res {
|
|
Some((height, tree)) => {
|
|
let tree = sync::CTree::read(&*tree)?;
|
|
let mut statement = self.connection.prepare(
|
|
&format!("SELECT id_note, witness FROM {}_witnesses w, received_notes n WHERE w.height = ?1 AND w.note = n.id_note AND (n.spent IS NULL OR n.spent = 0)", shielded_pool))?;
|
|
let ws = statement.query_map(params![height], |row| {
|
|
let id_note: u32 = row.get(0)?;
|
|
let witness: Vec<u8> = row.get(1)?;
|
|
Ok(sync::Witness::read(id_note, &*witness).unwrap())
|
|
})?;
|
|
let mut witnesses = vec![];
|
|
for w in ws {
|
|
witnesses.push(w?);
|
|
}
|
|
(tree, witnesses)
|
|
}
|
|
None => (sync::CTree::new(), vec![]),
|
|
})
|
|
}
|
|
|
|
pub fn get_nullifiers(&self) -> anyhow::Result<HashMap<Nf, NfRef>> {
|
|
let mut statement = self.connection.prepare(
|
|
"SELECT id_note, account, nf FROM received_notes WHERE spent IS NULL OR spent = 0",
|
|
)?;
|
|
let nfs_res = statement.query_map([], |row| {
|
|
let id_note: u32 = row.get(0)?;
|
|
let account: u32 = row.get(1)?;
|
|
let nf_vec: Vec<u8> = row.get(2)?;
|
|
let mut nf = [0u8; 32];
|
|
nf.clone_from_slice(&nf_vec);
|
|
let nf_ref = NfRef { id_note, account };
|
|
Ok((nf_ref, nf))
|
|
})?;
|
|
let mut nfs: HashMap<Nf, NfRef> = HashMap::new();
|
|
for n in nfs_res {
|
|
let n = n?;
|
|
nfs.insert(Nf(n.1), n.0);
|
|
}
|
|
|
|
Ok(nfs)
|
|
}
|
|
|
|
pub fn get_nullifier_amounts(
|
|
&self,
|
|
account: u32,
|
|
unspent_only: bool,
|
|
) -> anyhow::Result<HashMap<Vec<u8>, u64>> {
|
|
let mut sql = "SELECT value, nf FROM received_notes WHERE account = ?1".to_string();
|
|
if unspent_only {
|
|
sql += " AND (spent IS NULL OR spent = 0)";
|
|
}
|
|
let mut statement = self.connection.prepare(&sql)?;
|
|
let nfs_res = statement.query_map(params![account], |row| {
|
|
let amount: i64 = row.get(0)?;
|
|
let nf: Vec<u8> = row.get(1)?;
|
|
Ok((amount, nf))
|
|
})?;
|
|
let mut nfs: HashMap<Vec<u8>, u64> = HashMap::new();
|
|
for n in nfs_res {
|
|
let n = n?;
|
|
nfs.insert(n.1, n.0 as u64);
|
|
}
|
|
|
|
Ok(nfs)
|
|
}
|
|
|
|
pub fn get_unspent_nullifiers(
|
|
&self,
|
|
account: u32,
|
|
) -> anyhow::Result<Vec<ReceivedNoteShort>> {
|
|
let sql = "SELECT id_note, nf, value FROM received_notes WHERE account = ?1 AND (spent IS NULL OR spent = 0)";
|
|
let mut statement = self.connection.prepare(sql)?;
|
|
let nfs_res = statement.query_map(params![account], |row| {
|
|
let id: u32 = row.get(0)?;
|
|
let nf: Vec<u8> = row.get(1)?;
|
|
let value: i64 = row.get(2)?;
|
|
let nf: [u8; 32] = nf.try_into().unwrap();
|
|
let nf = Nf(nf);
|
|
Ok(ReceivedNoteShort {
|
|
id,
|
|
account,
|
|
nf,
|
|
value: value as u64,
|
|
})
|
|
})?;
|
|
let mut nfs = vec![];
|
|
for n in nfs_res {
|
|
let n = n?;
|
|
nfs.push(n);
|
|
}
|
|
Ok(nfs)
|
|
}
|
|
|
|
pub fn get_nullifiers_raw(&self) -> anyhow::Result<Vec<(u32, u64, Vec<u8>)>> {
|
|
let mut statement = self
|
|
.connection
|
|
.prepare("SELECT account, value, nf FROM received_notes")?;
|
|
let res = statement.query_map([], |row| {
|
|
let account: u32 = row.get(0)?;
|
|
let amount: i64 = row.get(1)?;
|
|
let nf: Vec<u8> = row.get(2)?;
|
|
Ok((account, amount as u64, nf))
|
|
})?;
|
|
let mut v: Vec<(u32, u64, Vec<u8>)> = vec![];
|
|
for r in res {
|
|
v.push(r?);
|
|
}
|
|
Ok(v)
|
|
}
|
|
|
|
// TODO: Depends on the type of witness - Should it returned any spendable note? sapling or orchard
|
|
pub fn get_spendable_notes(
|
|
&self,
|
|
account: u32,
|
|
anchor_height: u32,
|
|
fvk: &ExtendedFullViewingKey,
|
|
) -> anyhow::Result<Vec<SpendableNote>> {
|
|
let mut statement = self.connection.prepare(
|
|
"SELECT id_note, diversifier, value, rcm, witness FROM received_notes r, sapling_witnesses w WHERE spent IS NULL AND account = ?2
|
|
AND (r.excluded IS NULL OR NOT r.excluded) AND w.height = (
|
|
SELECT MAX(height) FROM sapling_witnesses WHERE height <= ?1
|
|
) AND r.id_note = w.note")?;
|
|
let notes = statement.query_map(params![anchor_height, account], |row| {
|
|
let id_note: u32 = row.get(0)?;
|
|
|
|
let diversifier: Vec<u8> = row.get(1)?;
|
|
let value: i64 = row.get(2)?;
|
|
let rcm: Vec<u8> = row.get(3)?;
|
|
let witness: Vec<u8> = row.get(4)?;
|
|
|
|
let mut diversifer_bytes = [0u8; 11];
|
|
diversifer_bytes.copy_from_slice(&diversifier);
|
|
let diversifier = Diversifier(diversifer_bytes);
|
|
let mut rcm_bytes = [0u8; 32];
|
|
rcm_bytes.copy_from_slice(&rcm);
|
|
let rcm = jubjub::Fr::from_bytes(&rcm_bytes).unwrap();
|
|
let rseed = Rseed::BeforeZip212(rcm);
|
|
let witness = IncrementalWitness::<Node>::read(&*witness).unwrap();
|
|
|
|
let pa = fvk.fvk.vk.to_payment_address(diversifier).unwrap();
|
|
let note = pa.create_note(value as u64, rseed).unwrap();
|
|
Ok(SpendableNote {
|
|
id: id_note,
|
|
note,
|
|
diversifier,
|
|
witness,
|
|
})
|
|
})?;
|
|
let mut spendable_notes: Vec<SpendableNote> = vec![];
|
|
for n in notes {
|
|
spendable_notes.push(n?);
|
|
}
|
|
|
|
Ok(spendable_notes)
|
|
}
|
|
|
|
pub fn tx_mark_spend(&mut self, selected_notes: &[u32]) -> anyhow::Result<()> {
|
|
let db_tx = self.begin_transaction()?;
|
|
for id_note in selected_notes.iter() {
|
|
DbAdapter::mark_spent(*id_note, 0, &db_tx)?;
|
|
}
|
|
db_tx.commit()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mark_spent(id: u32, height: u32, tx: &Transaction) -> anyhow::Result<()> {
|
|
log::debug!("+mark_spent");
|
|
tx.execute(
|
|
"UPDATE received_notes SET spent = ?1 WHERE id_note = ?2",
|
|
params![height, id],
|
|
)?;
|
|
log::debug!("-mark_spent");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn purge_old_witnesses(&mut self, height: u32) -> anyhow::Result<()> {
|
|
log::debug!("+purge_old_witnesses");
|
|
let min_height: Option<u32> = self.connection.query_row(
|
|
"SELECT MAX(height) FROM blocks WHERE height <= ?1",
|
|
params![height],
|
|
|row| row.get(0),
|
|
)?;
|
|
|
|
// Leave at least one sapling witness
|
|
if let Some(min_height) = min_height {
|
|
log::debug!("Purging witnesses older than {}", min_height);
|
|
let transaction = self.connection.transaction()?;
|
|
transaction.execute(
|
|
"DELETE FROM sapling_witnesses WHERE height < ?1",
|
|
params![min_height],
|
|
)?;
|
|
transaction.execute(
|
|
"DELETE FROM orchard_witnesses WHERE height < ?1",
|
|
params![min_height],
|
|
)?;
|
|
transaction.execute("DELETE FROM blocks WHERE height < ?1", params![min_height])?;
|
|
transaction.commit()?;
|
|
}
|
|
log::debug!("-purge_old_witnesses");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_contact(&self, contact: &Contact, dirty: bool) -> anyhow::Result<()> {
|
|
if contact.id == 0 {
|
|
self.connection.execute(
|
|
"INSERT INTO contacts(name, address, dirty)
|
|
VALUES (?1, ?2, ?3)",
|
|
params![&contact.name, &contact.address, dirty],
|
|
)?;
|
|
} else {
|
|
self.connection.execute(
|
|
"INSERT INTO contacts(id, name, address, dirty)
|
|
VALUES (?1, ?2, ?3, ?4) ON CONFLICT (id) DO UPDATE SET
|
|
name = excluded.name, address = excluded.address, dirty = excluded.dirty",
|
|
params![contact.id, &contact.name, &contact.address, dirty],
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_unsaved_contacts(&self) -> anyhow::Result<Vec<Contact>> {
|
|
let mut statement = self
|
|
.connection
|
|
.prepare("SELECT id, name, address FROM contacts WHERE dirty = TRUE")?;
|
|
let rows = statement.query_map([], |row| {
|
|
let id: u32 = row.get(0)?;
|
|
let name: String = row.get(1)?;
|
|
let address: String = row.get(2)?;
|
|
let contact = Contact { id, name, address };
|
|
Ok(contact)
|
|
})?;
|
|
let mut contacts: Vec<Contact> = vec![];
|
|
for r in rows {
|
|
contacts.push(r?);
|
|
}
|
|
|
|
Ok(contacts)
|
|
}
|
|
|
|
// TODO: Orchard diversifiers have a different space
|
|
pub fn get_diversifier(&self, account: u32) -> anyhow::Result<DiversifierIndex> {
|
|
let diversifier_index = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT diversifier_index FROM diversifiers WHERE account = ?1",
|
|
params![account],
|
|
|row| {
|
|
let d: Vec<u8> = row.get(0)?;
|
|
let mut div = [0u8; 11];
|
|
div.copy_from_slice(&d);
|
|
Ok(div)
|
|
},
|
|
)
|
|
.optional()?
|
|
.unwrap_or([0u8; 11]);
|
|
Ok(DiversifierIndex(diversifier_index))
|
|
}
|
|
|
|
// TODO: See get_diversifier
|
|
pub fn store_diversifier(
|
|
&self,
|
|
account: u32,
|
|
diversifier_index: &DiversifierIndex,
|
|
) -> anyhow::Result<()> {
|
|
let diversifier_bytes = diversifier_index.0.to_vec();
|
|
self.connection.execute(
|
|
"INSERT INTO diversifiers(account, diversifier_index) VALUES (?1, ?2) ON CONFLICT \
|
|
(account) DO UPDATE SET diversifier_index = excluded.diversifier_index",
|
|
params![account, diversifier_bytes],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_account_info(&self, account: u32) -> anyhow::Result<AccountData> {
|
|
let account_data = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT name, seed, sk, ivk, address, aindex FROM accounts WHERE id_account = ?1",
|
|
params![account],
|
|
|row| {
|
|
let name: String = row.get(0)?;
|
|
let seed: Option<String> = row.get(1)?;
|
|
let sk: Option<String> = row.get(2)?;
|
|
let fvk: String = row.get(3)?;
|
|
let address: String = row.get(4)?;
|
|
let aindex: u32 = row.get(5)?;
|
|
Ok(AccountData {
|
|
name,
|
|
seed,
|
|
sk,
|
|
fvk,
|
|
address,
|
|
aindex,
|
|
})
|
|
},
|
|
)
|
|
.map_err(wrap_query_no_rows("get_account_info"))?;
|
|
Ok(account_data)
|
|
}
|
|
|
|
pub fn get_taddr(&self, account: u32) -> anyhow::Result<Option<String>> {
|
|
let address = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT address FROM taddrs WHERE account = ?1",
|
|
params![account],
|
|
|row| {
|
|
let address: String = row.get(0)?;
|
|
Ok(address)
|
|
},
|
|
)
|
|
.optional()?;
|
|
Ok(address)
|
|
}
|
|
|
|
pub fn get_tsk(&self, account: u32) -> anyhow::Result<Option<String>> {
|
|
let sk = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT sk FROM taddrs WHERE account = ?1",
|
|
params![account],
|
|
|row| {
|
|
let address: String = row.get(0)?;
|
|
Ok(address)
|
|
},
|
|
)
|
|
.optional()?;
|
|
Ok(sk)
|
|
}
|
|
|
|
pub fn create_taddr(&self, account: u32) -> anyhow::Result<()> {
|
|
let AccountData { seed, aindex, .. } = self.get_account_info(account)?;
|
|
if let Some(seed) = seed {
|
|
let bip44_path = format!("m/44'/{}'/0'/0/{}", self.network().coin_type(), aindex);
|
|
let (sk, address) = derive_tkeys(self.network(), &seed, &bip44_path)?;
|
|
self.connection.execute(
|
|
"INSERT INTO taddrs(account, sk, address) VALUES (?1, ?2, ?3) \
|
|
ON CONFLICT DO NOTHING",
|
|
params![account, &sk, &address],
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_historical_prices(
|
|
&mut self,
|
|
prices: &[Quote],
|
|
currency: &str,
|
|
) -> anyhow::Result<()> {
|
|
let db_transaction = self.connection.transaction()?;
|
|
{
|
|
let mut statement = db_transaction.prepare(
|
|
"INSERT INTO historical_prices(timestamp, price, currency) VALUES (?1, ?2, ?3)",
|
|
)?;
|
|
for q in prices {
|
|
statement.execute(params![q.timestamp, q.price, currency])?;
|
|
}
|
|
}
|
|
db_transaction.commit()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_latest_quote(&self, currency: &str) -> anyhow::Result<Option<Quote>> {
|
|
let quote = self.connection.query_row(
|
|
"SELECT timestamp, price FROM historical_prices WHERE currency = ?1 ORDER BY timestamp DESC",
|
|
params![currency],
|
|
|row| {
|
|
let timestamp: i64 = row.get(0)?;
|
|
let price: f64 = row.get(1)?;
|
|
Ok(Quote { timestamp, price })
|
|
}).optional()?;
|
|
Ok(quote)
|
|
}
|
|
|
|
pub fn store_share_secret(
|
|
&self,
|
|
account: u32,
|
|
secret: &str,
|
|
index: usize,
|
|
threshold: usize,
|
|
participants: usize,
|
|
) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"INSERT INTO secret_shares(account, secret, idx, threshold, participants) VALUES (?1, ?2, ?3, ?4, ?5) \
|
|
ON CONFLICT (account) DO UPDATE SET secret = excluded.secret, threshold = excluded.threshold, participants = excluded.participants",
|
|
params![account, &secret, index as u32, threshold as u32, participants as u32],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_share_secret(&self, account: u32) -> anyhow::Result<String> {
|
|
let secret = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT secret FROM secret_shares WHERE account = ?1",
|
|
params![account],
|
|
|row| {
|
|
let secret: String = row.get(0)?;
|
|
Ok(secret)
|
|
},
|
|
)
|
|
.optional()?;
|
|
Ok(secret.unwrap_or("".to_string()))
|
|
}
|
|
|
|
pub fn truncate_data(&self) -> anyhow::Result<()> {
|
|
self.truncate_sync_data()?;
|
|
self.connection.execute("DELETE FROM diversifiers", [])?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn truncate_sync_data(&self) -> anyhow::Result<()> {
|
|
self.connection.execute("DELETE FROM blocks", [])?;
|
|
self.connection.execute("DELETE FROM contacts", [])?;
|
|
self.connection.execute("DELETE FROM diversifiers", [])?;
|
|
self.connection
|
|
.execute("DELETE FROM historical_prices", [])?;
|
|
self.connection.execute("DELETE FROM received_notes", [])?;
|
|
self.connection
|
|
.execute("DELETE FROM sapling_witnesses", [])?;
|
|
self.connection
|
|
.execute("DELETE FROM orchard_witnesses", [])?;
|
|
self.connection.execute("DELETE FROM transactions", [])?;
|
|
self.connection.execute("DELETE FROM messages", [])?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn delete_incomplete_scan(&mut self) -> anyhow::Result<()> {
|
|
let synced_height = self.get_last_sync_height()?;
|
|
if let Some(synced_height) = synced_height {
|
|
self.trim_to_height(synced_height)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn delete_account(&self, account: u32) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"DELETE FROM received_notes WHERE account = ?1",
|
|
params![account],
|
|
)?;
|
|
self.connection.execute(
|
|
"DELETE FROM transactions WHERE account = ?1",
|
|
params![account],
|
|
)?;
|
|
self.connection.execute(
|
|
"DELETE FROM diversifiers WHERE account = ?1",
|
|
params![account],
|
|
)?;
|
|
self.connection.execute(
|
|
"DELETE FROM accounts WHERE id_account = ?1",
|
|
params![account],
|
|
)?;
|
|
self.connection
|
|
.execute("DELETE FROM taddrs WHERE account = ?1", params![account])?;
|
|
self.connection
|
|
.execute("DELETE FROM messages WHERE account = ?1", params![account])?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_full_backup(&self, coin: u8) -> anyhow::Result<Vec<AccountBackup>> {
|
|
let mut statement = self.connection.prepare(
|
|
"SELECT name, seed, aindex, a.sk AS z_sk, ivk, a.address AS z_addr, t.sk as t_sk, t.address AS t_addr FROM accounts a LEFT JOIN taddrs t ON a.id_account = t.account")?;
|
|
let rows = statement.query_map([], |r| {
|
|
let name: String = r.get(0)?;
|
|
let seed: Option<String> = r.get(1)?;
|
|
let index: u32 = r.get(2)?;
|
|
let z_sk: Option<String> = r.get(3)?;
|
|
let ivk: String = r.get(4)?;
|
|
let z_addr: String = r.get(5)?;
|
|
let t_sk: Option<String> = r.get(6)?;
|
|
let t_addr: Option<String> = r.get(7)?;
|
|
Ok(AccountBackup {
|
|
coin,
|
|
name,
|
|
seed,
|
|
index,
|
|
z_sk,
|
|
ivk,
|
|
z_addr,
|
|
t_sk,
|
|
t_addr,
|
|
})
|
|
})?;
|
|
let mut accounts: Vec<AccountBackup> = vec![];
|
|
for r in rows {
|
|
accounts.push(r?);
|
|
}
|
|
Ok(accounts)
|
|
}
|
|
|
|
pub fn restore_full_backup(&self, accounts: &[AccountBackup]) -> anyhow::Result<()> {
|
|
let coin = get_coin_id(self.coin_type);
|
|
for a in accounts {
|
|
log::info!("{} {} {}", a.name, a.coin, coin);
|
|
if a.coin == coin {
|
|
let do_insert = || {
|
|
self.connection.execute("INSERT INTO accounts(name, seed, aindex, sk, ivk, address) VALUES (?1,?2,?3,?4,?5,?6)",
|
|
params![a.name, a.seed, a.index, a.z_sk, a.ivk, a.z_addr])?;
|
|
let id_account = self.connection.last_insert_rowid() as u32;
|
|
if let Some(t_addr) = &a.t_addr {
|
|
self.connection.execute(
|
|
"INSERT INTO taddrs(account, sk, address) VALUES (?1,?2,?3)",
|
|
params![id_account, a.t_sk, t_addr],
|
|
)?;
|
|
}
|
|
Ok::<_, anyhow::Error>(())
|
|
};
|
|
if let Err(e) = do_insert() {
|
|
log::info!("{:?}", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_message(&self, account: u32, message: &ZMessage) -> anyhow::Result<()> {
|
|
self.connection.execute("INSERT INTO messages(account, id_tx, sender, recipient, subject, body, timestamp, height, read) VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9)",
|
|
params![account, message.id_tx, message.sender, message.recipient, message.subject, message.body, message.timestamp, message.height, false])?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mark_message_read(&self, message_id: u32, read: bool) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"UPDATE messages SET read = ?1 WHERE id = ?2",
|
|
params![read, message_id],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mark_all_messages_read(&self, account: u32, read: bool) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"UPDATE messages SET read = ?1 WHERE account = ?2",
|
|
params![read, account],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn store_t_scan(&self, addresses: &[TBalance]) -> anyhow::Result<()> {
|
|
self.connection.execute(
|
|
"CREATE TABLE IF NOT EXISTS taddr_scan(\
|
|
id INTEGER NOT NULL PRIMARY KEY,
|
|
address TEXT NOT NULL,
|
|
value INTEGER NOT NULL,
|
|
aindex INTEGER NOT NULL)",
|
|
[],
|
|
)?;
|
|
for addr in addresses.iter() {
|
|
self.connection.execute(
|
|
"INSERT INTO taddr_scan(address, value, aindex) VALUES (?1, ?2, ?3)",
|
|
params![addr.address, addr.balance, addr.index],
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_accounts(&self) -> anyhow::Result<Vec<AccountRec>> {
|
|
let mut s = self
|
|
.connection
|
|
.prepare("SELECT id_account, name, address FROM accounts")?;
|
|
let accounts = s.query_map([], |row| {
|
|
let id_account: u32 = row.get(0)?;
|
|
let name: String = row.get(1)?;
|
|
let address: String = row.get(2)?;
|
|
Ok(AccountRec {
|
|
id_account,
|
|
name,
|
|
address,
|
|
})
|
|
})?;
|
|
let mut account_recs = vec![];
|
|
for row in accounts {
|
|
account_recs.push(row?);
|
|
}
|
|
Ok(account_recs)
|
|
}
|
|
|
|
pub fn get_txs(&self, account: u32) -> anyhow::Result<Vec<TxRec>> {
|
|
let mut s = self.connection.prepare("SELECT txid, height, timestamp, value, address, memo FROM transactions WHERE account = ?1")?;
|
|
let tx_rec = s.query_map(params![account], |row| {
|
|
let mut txid: Vec<u8> = row.get(0)?;
|
|
txid.reverse();
|
|
let txid = hex::encode(txid);
|
|
let height: u32 = row.get(1)?;
|
|
let timestamp: u32 = row.get(2)?;
|
|
let value: i64 = row.get(3)?;
|
|
let address: String = row.get(4)?;
|
|
let memo: String = row.get(5)?;
|
|
Ok(TxRec {
|
|
txid,
|
|
height,
|
|
timestamp,
|
|
value,
|
|
address,
|
|
memo,
|
|
})
|
|
})?;
|
|
let mut txs = vec![];
|
|
for row in tx_rec {
|
|
txs.push(row?);
|
|
}
|
|
Ok(txs)
|
|
}
|
|
|
|
pub fn import_from_syncdata(&mut self, account_info: &AccountInfo) -> anyhow::Result<Vec<u32>> {
|
|
// get id_account from fvk
|
|
// truncate received_notes, sapling_witnesses for account
|
|
// add new received_notes, sapling_witnesses
|
|
// add block
|
|
let id_account = self
|
|
.connection
|
|
.query_row(
|
|
"SELECT id_account FROM accounts WHERE ivk = ?1",
|
|
params![&account_info.fvk],
|
|
|row| {
|
|
let id_account: u32 = row.get(0)?;
|
|
Ok(id_account)
|
|
},
|
|
)
|
|
.map_err(wrap_query_no_rows("import_from_syncdata/id_account"))?;
|
|
self.connection.execute(
|
|
"DELETE FROM received_notes WHERE account = ?1",
|
|
params![id_account],
|
|
)?;
|
|
self.connection.execute(
|
|
"DELETE FROM transactions WHERE account = ?1",
|
|
params![id_account],
|
|
)?;
|
|
self.connection.execute(
|
|
"DELETE FROM messages WHERE account = ?1",
|
|
params![id_account],
|
|
)?;
|
|
let mut ids = vec![];
|
|
for tx in account_info.txs.iter() {
|
|
let mut tx_hash = hex::decode(&tx.hash)?;
|
|
tx_hash.reverse();
|
|
self.connection.execute("INSERT INTO transactions(account,txid,height,timestamp,value,address,memo,tx_index) VALUES (?1,?2,?3,?4,?5,'','',?6)",
|
|
params![id_account, &tx_hash, tx.height, tx.timestamp, tx.value, tx.index])?;
|
|
let id_tx = self.connection.last_insert_rowid() as u32;
|
|
ids.push(id_tx);
|
|
for n in tx.notes.iter() {
|
|
let spent = if n.spent == 0 { None } else { Some(n.spent) };
|
|
self.connection.execute("INSERT INTO received_notes(account,position,tx,height,output_index,diversifier,value,rcm,nf,spent,excluded) \
|
|
VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11)",
|
|
params![id_account, n.position as i64, id_tx, n.height, n.output_index, hex::decode(&n.diversifier)?, n.value as i64,
|
|
hex::decode(&n.rcm)?, &n.nf, spent, false])?;
|
|
let id_note = self.connection.last_insert_rowid() as u32;
|
|
self.connection.execute(
|
|
"INSERT INTO sapling_witnesses(note,height,witness) VALUES (?1,?2,?3) ON CONFLICT DO NOTHING",
|
|
params![
|
|
id_note,
|
|
account_info.height,
|
|
hex::decode(&n.witness).unwrap()
|
|
],
|
|
)?;
|
|
}
|
|
}
|
|
self.connection.execute("INSERT INTO blocks(height,hash,timestamp,sapling_tree) VALUES (?1,?2,?3,?4) ON CONFLICT(height) DO NOTHING",
|
|
params![account_info.height, hex::decode(&account_info.hash)?, account_info.timestamp, hex::decode(&account_info.sapling_tree)?])?;
|
|
self.trim_to_height(account_info.height)?;
|
|
Ok(ids)
|
|
}
|
|
|
|
fn network(&self) -> &'static Network {
|
|
let chain = get_coin_chain(self.coin_type);
|
|
chain.network()
|
|
}
|
|
}
|
|
|
|
pub struct ZMessage {
|
|
pub id_tx: u32,
|
|
pub sender: Option<String>,
|
|
pub recipient: String,
|
|
pub subject: String,
|
|
pub body: String,
|
|
pub timestamp: u32,
|
|
pub height: u32,
|
|
}
|
|
|
|
impl ZMessage {
|
|
pub fn is_empty(&self) -> bool {
|
|
self.sender.is_none() && self.subject.is_empty() && self.body.is_empty()
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct TxRec {
|
|
txid: String,
|
|
height: u32,
|
|
timestamp: u32,
|
|
value: i64,
|
|
address: String,
|
|
memo: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct AccountRec {
|
|
id_account: u32,
|
|
name: String,
|
|
address: String,
|
|
}
|
|
|
|
#[serde_as]
|
|
#[derive(Clone, Serialize, Deserialize, Debug)]
|
|
pub struct PlainNote {
|
|
pub height: u32,
|
|
pub value: u64,
|
|
#[serde_as(as = "serde_with::hex::Hex")]
|
|
pub nf: Vec<u8>,
|
|
pub position: u64,
|
|
pub tx_index: u32,
|
|
pub output_index: u32,
|
|
pub spent: u32,
|
|
pub witness: String,
|
|
pub rcm: String,
|
|
pub diversifier: String,
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct TxInfo {
|
|
pub height: u32,
|
|
pub timestamp: u32,
|
|
pub index: i64,
|
|
pub hash: String,
|
|
pub value: i64,
|
|
pub notes: Vec<PlainNote>,
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct OutputInfo {
|
|
pub tx_index: u32,
|
|
pub index: u32,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct AccountInfo {
|
|
pub fvk: String,
|
|
pub height: u32,
|
|
pub balance: u64,
|
|
pub txs: Vec<TxInfo>,
|
|
pub hash: String,
|
|
pub timestamp: u32,
|
|
pub sapling_tree: String,
|
|
}
|
|
|
|
pub struct AccountData {
|
|
pub name: String,
|
|
pub seed: Option<String>,
|
|
pub sk: Option<String>,
|
|
pub fvk: String,
|
|
pub address: String,
|
|
pub aindex: u32,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::db::{DbAdapter, DEFAULT_DB_PATH, ReceivedNote};
|
|
use crate::commitment::{CTree, Witness};
|
|
use zcash_params::coin::CoinType;
|
|
|
|
#[test]
|
|
fn test_db() {
|
|
let mut db = DbAdapter::new(CoinType::Zcash, DEFAULT_DB_PATH).unwrap();
|
|
db.init_db().unwrap();
|
|
db.trim_to_height(0).unwrap();
|
|
|
|
let db_tx = db.begin_transaction().unwrap();
|
|
DbAdapter::store_block(&db_tx, 1, &[0u8; 32], 0, &CTree::new(), None).unwrap();
|
|
let id_tx = DbAdapter::store_transaction(&[0; 32], 1, 1, 0, 20, &db_tx).unwrap();
|
|
DbAdapter::store_received_note(
|
|
&ReceivedNote {
|
|
account: 1,
|
|
height: 1,
|
|
output_index: 0,
|
|
diversifier: vec![],
|
|
value: 0,
|
|
rcm: vec![],
|
|
nf: vec![],
|
|
rho: None,
|
|
spent: None,
|
|
},
|
|
id_tx,
|
|
5,
|
|
&db_tx,
|
|
)
|
|
.unwrap();
|
|
let witness = Witness {
|
|
position: 10,
|
|
id_note: 0,
|
|
note: None,
|
|
tree: CTree::new(),
|
|
filled: vec![],
|
|
cursor: CTree::new(),
|
|
};
|
|
DbAdapter::store_witnesses(&db_tx, &witness, 1000, 1).unwrap();
|
|
db_tx.commit().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_balance() {
|
|
let db = DbAdapter::new(CoinType::Zcash, DEFAULT_DB_PATH).unwrap();
|
|
let balance = db.get_balance(1).unwrap();
|
|
println!("{}", balance);
|
|
}
|
|
}
|