From b875b64a0a9cc44330d637f6181d2a536354d050 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 27 May 2024 12:17:39 +0200
Subject: [PATCH] adapt api to new AnkMsg types

---
 crates/sp_client/src/api.rs | 58 ++++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 27 deletions(-)

diff --git a/crates/sp_client/src/api.rs b/crates/sp_client/src/api.rs
index d1edc07..19c49ba 100644
--- a/crates/sp_client/src/api.rs
+++ b/crates/sp_client/src/api.rs
@@ -36,7 +36,7 @@ use wasm_bindgen::prelude::*;
 
 use sdk_common::network::{
     self, AnkFlag, AnkNetworkMsg, CachedMessage, CachedMessageStatus, FaucetMessage, NewTxMessage,
-    UnknownMessage,
+    CipherMessage,
 };
 use sdk_common::silentpayments::{
     create_transaction, create_transaction_for_address_with_shared_secret,
@@ -49,7 +49,7 @@ use sp_client::spclient::{
 use sp_client::spclient::{SpWallet, SpendKey};
 
 use crate::user::{lock_connected_user, User, UserWallets, CONNECTED_USER};
-use crate::{images, lock_messages};
+use crate::{images, lock_messages, CACHEDMESSAGES};
 
 use crate::process::Process;
 
@@ -481,9 +481,9 @@ fn handle_recover_transaction(
             let plaintext = message
                 .try_decrypt_with_shared_secret(shared_secret.to_byte_array())
                 .unwrap();
-            let unknown_msg: UnknownMessage = serde_json::from_slice(&plaintext)?;
-            message.plaintext = Some(unknown_msg.message);
-            message.sender = Some(unknown_msg.sender);
+            let cipher_msg: CipherMessage = serde_json::from_slice(&plaintext)?;
+            message.plaintext = Some(cipher_msg.message);
+            message.sender = Some(cipher_msg.sender);
             message.recipient = Some(sp_wallet.get_client().get_receiving_address());
             message.status = CachedMessageStatus::ReceivedMustConfirm;
 
@@ -529,18 +529,6 @@ fn process_transaction(
 ) -> anyhow::Result<CachedMessage> {
     let tx = deserialize::<Transaction>(&Vec::from_hex(&tx_hex)?)?;
 
-    // check that we don't already have scanned the tx
-    if let Some(_) = lock_messages()?.iter().find(|message| {
-        if let Some(outpoint) = message.commited_in {
-            if outpoint.txid == tx.txid() {
-                return true;
-            }
-        }
-        return false;
-    }) {
-        return Err(anyhow::Error::msg("Transaction already scanned"));
-    }
-
     let tweak_data = PublicKey::from_str(&tweak_data_hex)?;
 
     let mut connected_user = lock_connected_user()?;
@@ -571,12 +559,26 @@ fn process_transaction(
     Err(anyhow::Error::msg("No output found"))
 }
 
+fn process_new_tx_error(msg: NewTxMessage) -> anyhow::Result<CachedMessage> {
+    // how do we match this error with the cached message?
+    unimplemented!();
+}
+
 #[wasm_bindgen]
 pub fn parse_network_msg(raw: String, fee_rate: u32) -> ApiResult<CachedMessage> {
     if let Ok(ank_msg) = serde_json::from_str::<AnkNetworkMsg>(&raw) {
         match ank_msg.flag {
             AnkFlag::NewTx => {
                 let tx_message = serde_json::from_str::<NewTxMessage>(&ank_msg.content)?;
+                if let Some(ref error) = tx_message.error {
+                    // Transaction failed to broadcast
+                    // we can retry later or check the availability of our spent output, depending on the actual error
+                    // we should probably look up the cached message and record the error
+                    log::error!("{}", error);
+                    // let updated = process_new_tx_error(tx_message)?;
+                    let updated = CachedMessage::new();
+                    return Ok(updated);
+                }
                 if tx_message.tweak_data.is_none() {
                     return Err(ApiError {
                         message: "Missing tweak_data".to_owned(),
@@ -590,12 +592,14 @@ pub fn parse_network_msg(raw: String, fee_rate: u32) -> ApiResult<CachedMessage>
                 )?;
                 return Ok(network_msg);
             }
-            AnkFlag::Faucet => unimplemented!(),
-            AnkFlag::Error => {
-                let error_msg = CachedMessage::new_error(ank_msg.content);
-                return Ok(error_msg);
-            }
-            AnkFlag::Unknown => {
+            AnkFlag::Faucet => {
+                let faucet_msg = serde_json::from_str::<FaucetMessage>(&ank_msg.content)?;
+                if let Some(error) = faucet_msg.error {
+                    debug!("Faucet msg returned with an error: {}", error);
+                }
+                unimplemented!();
+            },
+            AnkFlag::Cipher => {
                 // let's try to decrypt with keys we found in transactions but haven't used yet
                 let mut messages = lock_messages()?;
                 let cipher = Vec::from_hex(&ank_msg.content.trim_matches('\"'))?;
@@ -609,9 +613,9 @@ pub fn parse_network_msg(raw: String, fee_rate: u32) -> ApiResult<CachedMessage>
                 if cipher_pos.is_some() {
                     let mut message = messages.get_mut(cipher_pos.unwrap()).unwrap();
                     let plain = message.try_decrypt_cipher(cipher).unwrap();
-                    let unknown_msg: UnknownMessage = serde_json::from_slice(&plain)?;
-                    message.plaintext = Some(unknown_msg.message);
-                    message.sender = Some(unknown_msg.sender);
+                    let cipher_msg: CipherMessage = serde_json::from_slice(&plain)?;
+                    message.plaintext = Some(cipher_msg.message);
+                    message.sender = Some(cipher_msg.sender);
                     message.ciphertext = Some(ank_msg.content);
                     message.status = CachedMessageStatus::ReceivedMustConfirm;
                     return Ok(message.clone());
@@ -818,7 +822,7 @@ pub fn create_confirmation_transaction(
 #[wasm_bindgen]
 pub fn create_notification_transaction(
     address: String,
-    message: UnknownMessage,
+    message: CipherMessage,
     fee_rate: u32,
 ) -> ApiResult<createTransactionReturn> {
     let sp_address: SilentPaymentAddress = address.as_str().try_into()?;