lssa/integration_tests/tests/pinata.rs

use std::time::Duration;

use anyhow::{Context as _, Result};
use common::PINATA_BASE58;
use integration_tests::{
    ACC_SENDER, ACC_SENDER_PRIVATE, TIME_TO_WAIT_FOR_BLOCK_SECONDS, TestContext,
    format_private_account_id, format_public_account_id, verify_commitment_is_in_state,
};
use log::info;
use tokio::test;
use wallet::cli::{
    Command, SubcommandReturnValue,
    account::{AccountSubcommand, NewSubcommand},
    programs::pinata::PinataProgramAgnosticSubcommand,
};

#[test]
async fn claim_pinata_to_public_account() -> Result<()> {
    let mut ctx = TestContext::new().await?;

    let pinata_prize = 150;
    let command = Command::Pinata(PinataProgramAgnosticSubcommand::Claim {
        to: format_public_account_id(ACC_SENDER),
    });

    let pinata_balance_pre = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;

    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 = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    let winner_balance_post = ctx
        .sequencer_client()
        .get_account_balance(ACC_SENDER.to_string())
        .await?
        .balance;

    assert_eq!(pinata_balance_post, pinata_balance_pre - pinata_prize);
    assert_eq!(winner_balance_post, 10000 + pinata_prize);

    info!("Successfully claimed pinata to public account");

    Ok(())
}

#[test]
async fn claim_pinata_to_existing_private_account() -> Result<()> {
    let mut ctx = TestContext::new().await?;

    let pinata_prize = 150;
    let command = Command::Pinata(PinataProgramAgnosticSubcommand::Claim {
        to: format_private_account_id(ACC_SENDER_PRIVATE),
    });

    let pinata_balance_pre = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    let result = wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash: _ } = result else {
        anyhow::bail!("Expected PrivacyPreservingTransfer return value");
    };

    info!("Waiting for next block creation");
    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;

    info!("Syncing private accounts");
    let command = Command::Account(AccountSubcommand::SyncPrivate {});
    wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;

    let new_commitment = ctx
        .wallet()
        .get_private_account_commitment(&ACC_SENDER_PRIVATE.parse()?)
        .context("Failed to get private account commitment")?;
    assert!(verify_commitment_is_in_state(new_commitment, ctx.sequencer_client()).await);

    let pinata_balance_post = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    assert_eq!(pinata_balance_post, pinata_balance_pre - pinata_prize);

    info!("Successfully claimed pinata to existing private account");

    Ok(())
}

#[test]
async fn claim_pinata_to_new_private_account() -> Result<()> {
    let mut ctx = TestContext::new().await?;

    let pinata_prize = 150;

    // Create new private account
    let result = wallet::cli::execute_subcommand(
        ctx.wallet_mut(),
        Command::Account(AccountSubcommand::New(NewSubcommand::Private { cci: None })),
    )
    .await?;
    let SubcommandReturnValue::RegisterAccount {
        account_id: winner_account_id,
    } = result
    else {
        anyhow::bail!("Expected RegisterAccount return value");
    };

    let command = Command::Pinata(PinataProgramAgnosticSubcommand::Claim {
        to: format_private_account_id(&winner_account_id.to_string()),
    });

    let pinata_balance_pre = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;

    info!("Waiting for next block creation");
    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;

    let new_commitment = ctx
        .wallet()
        .get_private_account_commitment(&winner_account_id)
        .context("Failed to get private account commitment")?;
    assert!(verify_commitment_is_in_state(new_commitment, ctx.sequencer_client()).await);

    let pinata_balance_post = ctx
        .sequencer_client()
        .get_account_balance(PINATA_BASE58.to_string())
        .await?
        .balance;

    assert_eq!(pinata_balance_post, pinata_balance_pre - pinata_prize);

    info!("Successfully claimed pinata to new private account");

    Ok(())
}