Merge pull request #13 from ABlockOfficial/znp_update

Updating Network to ZNP Public Merge

Author: BHouwens

src/api/errors.rs

@@ -16,6 +16,7 @@ pub enum ApiErrorType {
     CannotParseAddress,
     CannotAccessWallet,
     CannotAccessUserNode,
+    CannotAccessMinerNode,
     CannotAccessComputeNode,
     CannotAccessPeerUserNode,
     CannotSaveAddressesToWallet,
@@ -57,6 +58,7 @@ impl std::fmt::Display for ApiErrorType {
             ApiErrorType::CannotParseAddress => write!(f, "Cannot parse address"),
             ApiErrorType::CannotAccessWallet => write!(f, "Cannot access wallet"),
             ApiErrorType::CannotAccessUserNode => write!(f, "Cannot access user node"),
+            ApiErrorType::CannotAccessMinerNode => write!(f, "Cannot access miner node"),
             ApiErrorType::CannotAccessComputeNode => write!(f, "Cannot access compute node"),
             ApiErrorType::CannotAccessPeerUserNode => write!(f, "Cannot access peer user node"),
             ApiErrorType::CannotSaveAddressesToWallet => {

src/api/handlers.rs

@@ -11,8 +11,8 @@ use crate::constants::LAST_BLOCK_HASH_KEY;
 use crate::db_utils::SimpleDb;
 use crate::interfaces::{
     node_type_as_str, AddressesWithOutPoints, BlockchainItem, BlockchainItemMeta,
-    BlockchainItemType, ComputeApi, DebugData, DruidPool, OutPointData, StoredSerializingBlock,
-    UserApiRequest, UserRequest, UtxoFetchType,
+    BlockchainItemType, ComputeApi, DebugData, DruidPool, MineApiRequest, MineRequest, NodeType,
+    OutPointData, StoredSerializingBlock, UserApiRequest, UserRequest, UtxoFetchType,
 };
 use crate::miner::{BlockPoWReceived, CurrentBlockWithMutex};
 use crate::storage::{get_stored_value_from_db, indexed_block_hash_key};
@@ -55,6 +55,11 @@ pub struct Addresses {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct WalletInfo {
     running_total: f64,
+    running_total_tokens: u64,
+    locked_total: f64,
+    locked_total_tokens: u64,
+    available_total: f64,
+    available_total_tokens: u64,
     item_total: BTreeMap<String, u64>, /* DRS tx hash - amount */
     addresses: AddressesWithOutPoints,
 }
@@ -71,6 +76,7 @@ pub struct EncapsulatedPayment {
     pub address: String,
     pub amount: TokenAmount,
     pub passphrase: String,
+    pub locktime: Option<u64>,
 }
 
 /// Item asset creation structure received from client
@@ -172,7 +178,7 @@ pub async fn get_wallet_info(
 ) -> Result<JsonReply, JsonReply> {
     let r = CallResponse::new(route, &call_id);
 
-    let fund_store = match wallet_db.get_fund_store_err() {
+    let mut fund_store = match wallet_db.get_fund_store_err() {
         Ok(fund) => fund,
         Err(_) => return r.into_err_internal(ApiErrorType::CannotAccessWallet),
     };
@@ -200,15 +206,20 @@ pub async fn get_wallet_info(
             .or_default()
             .push(OutPointData::new(out_point.clone(), asset.clone()));
     }
-
-    let total = fund_store.running_total();
-    let (running_total, item_total) = (
-        total.tokens.0 as f64 / D_DISPLAY_PLACES,
-        total.items.clone(),
-    );
+    let locked_coinbase = wallet_db.get_locked_coinbase().await;
+    let total = fund_store.running_total().clone();
+    let available = {
+        fund_store.filter_locked_coinbase(&locked_coinbase);
+        fund_store.running_total()
+    };
     let send_val = WalletInfo {
-        running_total,
-        item_total,
+        running_total: total.tokens.0 as f64 / D_DISPLAY_PLACES,
+        running_total_tokens: total.tokens.0,
+        locked_total: (total.tokens.0 - available.tokens.0) as f64 / D_DISPLAY_PLACES,
+        locked_total_tokens: (total.tokens.0 - available.tokens.0),
+        available_total: available.tokens.0 as f64 / D_DISPLAY_PLACES,
+        available_total_tokens: available.tokens.0,
+        item_total: total.items,
         addresses,
     };
 
@@ -401,6 +412,7 @@ pub async fn post_block_by_num(
 
 /// Post to import new keypairs to the connected wallet
 pub async fn post_import_keypairs(
+    peer: Node,
     db: WalletDb,
     keypairs: Addresses,
     route: &'static str,
@@ -409,6 +421,7 @@ pub async fn post_import_keypairs(
     let response_keys: Vec<String> = keypairs.addresses.keys().cloned().collect();
     let response_data = json_serialize_embed(response_keys);
     let r = CallResponse::new(route, &call_id);
+    let addresses: Vec<String> = keypairs.addresses.keys().cloned().collect();
 
     let mut key_pairs_converted = BTreeMap::new();
     for (address, address_store_hex) in keypairs.addresses.into_iter() {
@@ -439,6 +452,34 @@ pub async fn post_import_keypairs(
         }
     }
 
+    match peer.get_node_type() {
+        NodeType::Miner => {
+            // Update running total from compute node
+            if let Err(e) = peer.inject_next_event(
+                peer.local_address(),
+                MineRequest::MinerApi(MineApiRequest::RequestUTXOSet(UtxoFetchType::AnyOf(
+                    addresses,
+                ))),
+            ) {
+                error!("route:update_running_total error: {:?}", e);
+                return r.into_err_internal(ApiErrorType::CannotAccessMinerNode);
+            }
+        }
+        NodeType::User => {
+            // Update running total from compute node
+            if let Err(e) = peer.inject_next_event(
+                peer.local_address(),
+                UserRequest::UserApi(UserApiRequest::UpdateWalletFromUtxoSet {
+                    address_list: UtxoFetchType::AnyOf(addresses),
+                }),
+            ) {
+                error!("route:update_running_total error: {:?}", e);
+                return r.into_err_internal(ApiErrorType::CannotAccessUserNode);
+            }
+        }
+        _ => return r.into_err_internal(ApiErrorType::InternalError),
+    }
+
     r.into_ok("Key-pairs successfully imported", response_data)
 }
 
@@ -454,6 +495,7 @@ pub async fn post_make_payment(
         address,
         amount,
         passphrase,
+        locktime,
     } = encapsulated_data;
 
     let r = CallResponse::new(route, &call_id);
@@ -462,6 +504,7 @@ pub async fn post_make_payment(
         Ok(_) => UserRequest::UserApi(UserApiRequest::MakePayment {
             address: address.clone(),
             amount,
+            locktime,
         }),
         Err(e) => {
             return wallet_db_error(e, r);
@@ -491,6 +534,7 @@ pub async fn post_make_ip_payment(
         address,
         amount,
         passphrase,
+        locktime,
     } = encapsulated_data;
 
     let r = CallResponse::new(route, &call_id);
@@ -506,6 +550,7 @@ pub async fn post_make_ip_payment(
         Ok(_) => UserRequest::UserApi(UserApiRequest::MakeIpPayment {
             payment_peer,
             amount,
+            locktime,
         }),
         Err(e) => {
             return wallet_db_error(e, r);

src/api/routes.rs

@@ -349,6 +349,7 @@ pub fn transactions_by_key(
 pub fn import_keypairs(
     dp: &mut DbgPaths,
     db: WalletDb,
+    node: Node,
     routes_pow: RoutesPoWInfo,
     api_keys: ApiKeys,
     cache: ReplyCache,
@@ -358,13 +359,14 @@ pub fn import_keypairs(
         .and(warp::post())
         .and(auth_request(routes_pow, api_keys))
         .and(with_node_component(db))
+        .and(with_node_component(node))
         .and(warp::body::json())
         .and(with_node_component(cache))
-        .and_then(move |call_id: String, db, kp, cache| {
+        .and_then(move |call_id: String, db, node, kp, cache| {
             map_api_res_and_cache(
                 call_id.clone(),
                 cache,
-                handlers::post_import_keypairs(db, kp, route, call_id),
+                handlers::post_import_keypairs(node, db, kp, route, call_id),
             )
         })
         .with(post_cors())
@@ -800,6 +802,7 @@ pub fn user_node_routes(
     .or(import_keypairs(
         dp,
         db.clone(),
+        node.clone(),
         routes_pow_info.clone(),
         api_keys.clone(),
         cache.clone(),
@@ -1030,6 +1033,7 @@ pub fn miner_node_routes(
     .or(import_keypairs(
         dp,
         db.clone(),
+        node.clone(),
         routes_pow_info.clone(),
         api_keys.clone(),
         cache.clone(),
@@ -1126,6 +1130,7 @@ pub fn miner_node_with_user_routes(
     .or(import_keypairs(
         dp,
         db.clone(),
+        user_node.clone(),
         routes_pow_info.clone(),
         api_keys.clone(),
         cache.clone(),