github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

wallet: use serialize and deserialize functions directly wihout wraping

Browse Source
This commit is contained in:
ghassmo
2022-04-26 00:34:19 +03:00
parent 2fa2d75cab
commit 1b2daf0a4e
2 changed files with 74 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/wallet/cashierdb.rs
View File

@@ -8,15 +8,16 @@ use sqlx::{
ConnectOptions, Row, SqlitePool,
};
use super::wallet_api::WalletApi;
use crate::{
crypto::{
keypair::{Keypair, PublicKey, SecretKey},
merkle_node::MerkleNode,
types::DrkTokenId,
},
util::NetworkName,
util::{
serial::{deserialize, serialize},
NetworkName,
},
Error::{WalletEmptyPassword, WalletTreeExists},
Result,
};
@@ -47,8 +48,6 @@ pub struct CashierDb {
pub conn: SqlitePool,
}
impl WalletApi for CashierDb {}
impl CashierDb {
pub async fn new(path: &str, password: &str) -> Result<CashierDbPtr> {
debug!("new() Constructor called");
@@ -138,7 +137,7 @@ impl CashierDb {
pub async fn put_main_keys(&self, token_key: &TokenKey, network: &NetworkName) -> Result<()> {
debug!("Writing main keys into the database");
let network = self.get_value_serialized(network)?;
let network = serialize(network);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -158,7 +157,7 @@ impl CashierDb {
pub async fn get_main_keys(&self, network: &NetworkName) -> Result<Vec<TokenKey>> {
debug!("Returning main keypairs");
let network = self.get_value_serialized(network)?;
let network = serialize(network);
let mut conn = self.conn.acquire().await?;
@@ -199,12 +198,12 @@ impl CashierDb {
mint_address: String,
) -> Result<()> {
debug!("Writing withdraw keys to database");
let public = self.get_value_serialized(d_key_public)?;
let secret = self.get_value_serialized(d_key_secret)?;
let network = self.get_value_serialized(network)?;
let token_id = self.get_value_serialized(token_id)?;
let confirm = self.get_value_serialized(&false)?;
let mint_address = self.get_value_serialized(&mint_address)?;
let public = serialize(d_key_public);
let secret = serialize(d_key_secret);
let network = serialize(network);
let token_id = serialize(token_id);
let confirm = serialize(&false);
let mint_address = serialize(&mint_address);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -237,11 +236,11 @@ impl CashierDb {
mint_address: String,
) -> Result<()> {
debug!("Writing deposit keys to database");
let d_key_public = self.get_value_serialized(d_key_public)?;
let token_id = self.get_value_serialized(token_id)?;
let network = self.get_value_serialized(network)?;
let confirm = self.get_value_serialized(&false)?;
let mint_address = self.get_value_serialized(&mint_address)?;
let d_key_public = serialize(d_key_public);
let token_id = serialize(token_id);
let network = serialize(network);
let confirm = serialize(&false);
let mint_address = serialize(&mint_address);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -266,7 +265,7 @@ impl CashierDb {
pub async fn get_withdraw_private_keys(&self) -> Result<Vec<SecretKey>> {
debug!("Getting withdraw private keys");
let confirm = self.get_value_serialized(&false)?;
let confirm = serialize(&false);
let mut conn = self.conn.acquire().await?;
let rows = sqlx::query(
@@ -279,7 +278,7 @@ impl CashierDb {
let mut secret_keys = vec![];
for row in rows {
let key: SecretKey = self.get_value_deserialized(row.get("d_key_secret"))?;
let key: SecretKey = deserialize(row.get("d_key_secret"))?;
secret_keys.push(key);
}
@@ -291,8 +290,8 @@ impl CashierDb {
pubkey: &PublicKey,
) -> Result<Option<WithdrawToken>> {
debug!("Get token address by pubkey");
let d_key_public = self.get_value_serialized(pubkey)?;
let confirm = self.get_value_serialized(&false)?;
let d_key_public = serialize(pubkey);
let confirm = serialize(&false);
let mut conn = self.conn.acquire().await?;
let rows = sqlx::query(
@@ -309,9 +308,9 @@ impl CashierDb {
let mut token_addrs = vec![];
for row in rows {
let token_public_key = row.get("token_key_public");
let network = self.get_value_deserialized(row.get("network"))?;
let token_id = self.get_value_deserialized(row.get("token_id"))?;
let mint_address = self.get_value_deserialized(row.get("mint_address"))?;
let network = deserialize(row.get("network"))?;
let token_id = deserialize(row.get("token_id"))?;
let mint_address = deserialize(row.get("mint_address"))?;
token_addrs.push(WithdrawToken { token_public_key, network, token_id, mint_address });
}
@@ -325,9 +324,9 @@ impl CashierDb {
network: &NetworkName,
) -> Result<Vec<TokenKey>> {
debug!("Checking for existing dkey");
let d_key_public = self.get_value_serialized(d_key_public)?;
let network = self.get_value_serialized(network)?;
let confirm = self.get_value_serialized(&false)?;
let d_key_public = serialize(d_key_public);
let network = serialize(network);
let confirm = serialize(&false);
let mut conn = self.conn.acquire().await?;
let rows = sqlx::query(
@@ -359,8 +358,8 @@ impl CashierDb {
network: &NetworkName,
) -> Result<Option<Keypair>> {
debug!("Checking for existing token address");
let confirm = self.get_value_serialized(&false)?;
let network = self.get_value_serialized(network)?;
let confirm = serialize(&false);
let network = serialize(network);
let mut conn = self.conn.acquire().await?;
let rows = sqlx::query(
@@ -377,8 +376,8 @@ impl CashierDb {
let mut keypairs = vec![];
for row in rows {
let public = self.get_value_deserialized(row.get("d_key_public"))?;
let secret = self.get_value_deserialized(row.get("d_key_secret"))?;
let public = deserialize(row.get("d_key_public"))?;
let secret = deserialize(row.get("d_key_secret"))?;
keypairs.push(Keypair { public, secret });
}
@@ -391,8 +390,8 @@ impl CashierDb {
network: &NetworkName,
) -> Result<()> {
debug!("Confirm withdraw keys");
let network = self.get_value_serialized(network)?;
let confirm = self.get_value_serialized(&true)?;
let network = serialize(network);
let confirm = serialize(&true);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -416,9 +415,9 @@ impl CashierDb {
network: &NetworkName,
) -> Result<()> {
debug!("Confirm deposit keys");
let network = self.get_value_serialized(network)?;
let confirm = self.get_value_serialized(&true)?;
let d_key_public = self.get_value_serialized(d_key_public)?;
let network = serialize(network);
let confirm = serialize(&true);
let d_key_public = serialize(d_key_public);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -441,8 +440,8 @@ impl CashierDb {
network: &NetworkName,
) -> Result<Vec<DepositToken>> {
debug!("Checking for existing dkey");
let network = self.get_value_serialized(network)?;
let confirm = self.get_value_serialized(&false)?;
let network = serialize(network);
let confirm = serialize(&false);
let mut conn = self.conn.acquire().await?;
let rows = sqlx::query(
@@ -459,11 +458,11 @@ impl CashierDb {
let mut keys = vec![];
for row in rows {
let drk_public_key = self.get_value_deserialized(row.get("d_key_public"))?;
let drk_public_key = deserialize(row.get("d_key_public"))?;
let secret_key = row.get("token_key_secret");
let public_key = row.get("token_key_public");
let token_id = self.get_value_deserialized(row.get("token_id"))?;
let mint_address = self.get_value_deserialized(row.get("mint_address"))?;
let token_id = deserialize(row.get("token_id"))?;
let mint_address = deserialize(row.get("mint_address"))?;
keys.push(DepositToken {
drk_public_key,
token_key: TokenKey { secret_key, public_key },

66
src/wallet/walletdb.rs
View File

@@ -20,13 +20,14 @@ use crate::{
types::DrkTokenId,
OwnCoin, OwnCoins,
},
util::{expand_path, serial::serialize},
util::{
expand_path,
serial::{deserialize, serialize},
},
Error::{WalletEmptyPassword, WalletTreeExists},
Result,
};
use super::wallet_api::WalletApi;
pub type WalletPtr = Arc<WalletDb>;
#[derive(Clone, Debug)]
@@ -45,8 +46,6 @@ pub struct WalletDb {
pub conn: SqlitePool,
}
impl WalletApi for WalletDb {}
/// Helper function to initialize `WalletPtr`
pub async fn init_wallet(wallet_path: &str, wallet_pass: &str) -> Result<WalletPtr> {
let expanded = expand_path(wallet_path)?;
@@ -158,8 +157,8 @@ impl WalletDb {
.fetch_one(&mut conn)
.await?;
let public: PublicKey = self.get_value_deserialized(row.get("public"))?;
let secret: SecretKey = self.get_value_deserialized(row.get("secret"))?;
let public: PublicKey = deserialize(row.get("public"))?;
let secret: SecretKey = deserialize(row.get("secret"))?;
Ok(Keypair { secret, public })
}
@@ -195,8 +194,8 @@ impl WalletDb {
let mut keypairs = vec![];
for row in sqlx::query("SELECT * FROM keys").fetch_all(&mut conn).await? {
let public: PublicKey = self.get_value_deserialized(row.get("public"))?;
let secret: SecretKey = self.get_value_deserialized(row.get("secret"))?;
let public: PublicKey = deserialize(row.get("public"))?;
let secret: SecretKey = deserialize(row.get("secret"))?;
keypairs.push(Keypair { public, secret });
}
@@ -259,21 +258,21 @@ impl WalletDb {
let mut own_coins = vec![];
for row in rows {
let coin = self.get_value_deserialized(row.get("coin"))?;
let coin = deserialize(row.get("coin"))?;
// Note
let serial = self.get_value_deserialized(row.get("serial"))?;
let coin_blind = self.get_value_deserialized(row.get("coin_blind"))?;
let value_blind = self.get_value_deserialized(row.get("valcom_blind"))?;
let serial = deserialize(row.get("serial"))?;
let coin_blind = deserialize(row.get("coin_blind"))?;
let value_blind = deserialize(row.get("valcom_blind"))?;
// TODO: FIXME:
let value_bytes: Vec<u8> = row.get("value");
let value = u64::from_le_bytes(value_bytes.try_into().unwrap());
let token_id = self.get_value_deserialized(row.get("token_id"))?;
let token_id = deserialize(row.get("token_id"))?;
let note = Note { serial, value, token_id, coin_blind, value_blind };
let secret = self.get_value_deserialized(row.get("secret"))?;
let nullifier = self.get_value_deserialized(row.get("nullifier"))?;
let leaf_position = self.get_value_deserialized(row.get("leaf_position"))?;
let secret = deserialize(row.get("secret"))?;
let nullifier = deserialize(row.get("nullifier"))?;
let leaf_position = deserialize(row.get("leaf_position"))?;
let oc = OwnCoin { coin, note, secret, nullifier, leaf_position };
@@ -285,16 +284,17 @@ impl WalletDb {
pub async fn put_own_coin(&self, own_coin: OwnCoin) -> Result<()> {
debug!("Putting own coin into wallet database");
let coin = self.get_value_serialized(&own_coin.coin.to_bytes())?;
let serial = self.get_value_serialized(&own_coin.note.serial)?;
let coin_blind = self.get_value_serialized(&own_coin.note.coin_blind)?;
let value_blind = self.get_value_serialized(&own_coin.note.value_blind)?;
let coin = serialize(&own_coin.coin.to_bytes());
let serial = serialize(&own_coin.note.serial);
let coin_blind = serialize(&own_coin.note.coin_blind);
let value_blind = serialize(&own_coin.note.value_blind);
let value = own_coin.note.value.to_le_bytes();
let token_id = self.get_value_serialized(&own_coin.note.token_id)?;
let secret = self.get_value_serialized(&own_coin.secret)?;
let is_spent = 0;
let nullifier = self.get_value_serialized(&own_coin.nullifier)?;
let leaf_position = self.get_value_serialized(&own_coin.leaf_position)?;
let token_id = serialize(&own_coin.note.token_id);
let secret = serialize(&own_coin.secret);
let is_spent: u32 = 0;
let nullifier = serialize(&own_coin.nullifier);
let leaf_position = serialize(&own_coin.leaf_position);
let mut conn = self.conn.acquire().await?;
sqlx::query(
@@ -330,8 +330,8 @@ impl WalletDb {
pub async fn confirm_spend_coin(&self, coin: &Coin) -> Result<()> {
debug!("Confirm spend coin");
let is_spent = 1;
let coin = self.get_value_serialized(coin)?;
let is_spent: u32 = 1;
let coin = serialize(coin);
let mut conn = self.conn.acquire().await?;
sqlx::query("UPDATE coins SET is_spent = ?1 WHERE coin = ?2;")
@@ -360,8 +360,8 @@ impl WalletDb {
// TODO: FIXME:
let value_bytes: Vec<u8> = row.get("value");
let value = u64::from_le_bytes(value_bytes.try_into().unwrap());
let token_id = self.get_value_deserialized(row.get("token_id"))?;
let nullifier = self.get_value_deserialized(row.get("nullifier"))?;
let token_id = deserialize(row.get("token_id"))?;
let nullifier = deserialize(row.get("nullifier"))?;
list.push(Balance { token_id, value, nullifier });
}
@@ -380,7 +380,7 @@ impl WalletDb {
let mut token_ids = vec![];
for row in rows {
let token_id = self.get_value_deserialized(row.get("token_id"))?;
let token_id = deserialize(row.get("token_id"))?;
token_ids.push(token_id);
}
@@ -390,8 +390,8 @@ impl WalletDb {
pub async fn token_id_exists(&self, token_id: DrkTokenId) -> Result<bool> {
debug!("Checking if token ID exists");
let is_spent = 0;
let id = self.get_value_serialized(&token_id)?;
let is_spent: u32 = 0;
let id = serialize(&token_id);
let mut conn = self.conn.acquire().await?;