feat: wallet method for private pinata claim

ci_scripts/test-ubuntu.sh

@@ -9,11 +9,12 @@ RISC0_DEV_MODE=1 cargo test --release
 cd integration_tests
 export NSSA_WALLET_HOME_DIR=$(pwd)/configs/debug/wallet/
 export RUST_LOG=info
-cargo run $(pwd)/configs/debug all
 echo "Try test valid proof at least once"
 cargo run $(pwd)/configs/debug test_success_private_transfer_to_another_owned_account
 echo "Continuing in dev mode"
 RISC0_DEV_MODE=1 cargo run $(pwd)/configs/debug all
+echo "ToDo remove after Draft"
+cargo run $(pwd)/configs/debug test_pinata_private_receiver
 cd ..
 
 cd nssa/program_methods/guest && cargo test --release

integration_tests/src/lib.rs

@@ -457,7 +457,7 @@ pub async fn test_success_private_transfer_to_another_owned_account() {
         to: to.to_string(),
         amount: 100,
     };
-
+    //
     let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
         wallet::execute_subcommand(command).await.unwrap()
     else {
@@ -791,6 +791,65 @@ pub async fn test_pinata() {
     info!("Success!");
 }
 
+pub async fn test_pinata_private_receiver() {
+    info!("test_pinata_private_receiver");
+    let pinata_addr = "cafe".repeat(16);
+    let pinata_prize = 150;
+    let solution = 989106;
+
+    let command = Command::ClaimPinataPrivateReceiverOwned {
+        pinata_addr: pinata_addr.clone(),
+        winner_addr: ACC_SENDER_PRIVATE.to_string(),
+        solution,
+    };
+
+    let wallet_config = fetch_config().unwrap();
+
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+
+    let pinata_balance_pre = seq_client
+        .get_account_balance(pinata_addr.clone())
+        .await
+        .unwrap()
+        .balance;
+
+    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
+        wallet::execute_subcommand(command).await.unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    info!("Checking correct balance move");
+    let pinata_balance_post = seq_client
+        .get_account_balance(pinata_addr.clone())
+        .await
+        .unwrap()
+        .balance;
+
+    let command = Command::FetchPrivateAccount {
+        tx_hash: tx_hash.clone(),
+        acc_addr: ACC_SENDER_PRIVATE.to_string(),
+        output_id: 0,
+    };
+    wallet::execute_subcommand(command).await.unwrap();
+
+    let wallet_config = fetch_config().unwrap();
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&ACC_SENDER_PRIVATE.parse().unwrap())
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    assert_eq!(pinata_balance_post, pinata_balance_pre - pinata_prize);
+
+    info!("Success!");
+}
+
 macro_rules! test_cleanup_wrap {
     ($home_dir:ident, $test_func:ident) => {{
         let res = pre_test($home_dir.clone()).await.unwrap();
@@ -871,6 +930,9 @@ pub async fn main_tests_runner() -> Result<()> {
         "test_pinata" => {
             test_cleanup_wrap!(home_dir, test_pinata);
         }
+        "test_pinata_private_receiver" => {
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver);
+        }
         "all" => {
             test_cleanup_wrap!(home_dir, test_success_move_to_another_account);
             test_cleanup_wrap!(home_dir, test_success);

wallet/src/lib.rs

@@ -456,6 +456,19 @@ pub enum Command {
         #[arg(long)]
         solution: u128,
     },
+    // TODO: Testnet only. Refactor to prevent compilation on mainnet.
+    // Claim piñata prize
+    ClaimPinataPrivateReceiverOwned {
+        ///pinata_addr - valid 32 byte hex string
+        #[arg(long)]
+        pinata_addr: String,
+        ///winner_addr - valid 32 byte hex string
+        #[arg(long)]
+        winner_addr: String,
+        ///solution - solution to pinata challenge
+        #[arg(long)]
+        solution: u128,
+    },
 }
 
 ///To execute commands, env var NSSA_WALLET_HOME_DIR must be set into directory with config
@@ -926,6 +939,51 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
 
             SubcommandReturnValue::Empty
         }
+        Command::ClaimPinataPrivateReceiverOwned {
+            pinata_addr,
+            winner_addr,
+            solution,
+        } => {
+            let pinata_addr = pinata_addr.parse().unwrap();
+            let winner_addr = winner_addr.parse().unwrap();
+
+            let (res, [secret_winner]) = wallet_core
+                .claim_pinata_private_owned_account(pinata_addr, winner_addr, solution)
+                .await?;
+            info!("Results of tx send is {res:#?}");
+
+            let tx_hash = res.tx_hash;
+            let transfer_tx = wallet_core
+                .poll_native_token_transfer(tx_hash.clone())
+                .await?;
+
+            if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx {
+                let winner_ead = tx.message.encrypted_private_post_states[0].clone();
+                let winner_comm = tx.message.new_commitments[0].clone();
+
+                let res_acc_winner = nssa_core::EncryptionScheme::decrypt(
+                    &winner_ead.ciphertext,
+                    &secret_winner,
+                    &winner_comm,
+                    0,
+                )
+                .unwrap();
+
+                println!("Received new from acc {res_acc_winner:#?}");
+
+                println!("Transaction data is {:?}", tx.message);
+
+                wallet_core
+                    .storage
+                    .insert_private_account_data(winner_addr, res_acc_winner);
+            }
+
+            let path = wallet_core.store_persistent_accounts()?;
+
+            println!("Stored persistent accounts at {path:#?}");
+
+            SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }
+        }
     };
 
     Ok(subcommand_ret)