Merge branch 'main' into schouhy/add-program-deployment-transactions

ci_scripts/test-ubuntu.sh

@@ -4,7 +4,7 @@ curl -L https://risczero.com/install | bash
 /home/runner/.risc0/bin/rzup install 
 source env.sh
 
-RISC0_DEV_MODE=1 cargo test --release
+RISC0_DEV_MODE=1 cargo test --release --features no_docker
 
 cd integration_tests
 export NSSA_WALLET_HOME_DIR=$(pwd)/configs/debug/wallet/

common/Cargo.toml

@@ -19,5 +19,9 @@ hex.workspace = true
 nssa-core = { path = "../nssa/core", features = ["host"] }
 borsh.workspace = true
 
+[dependencies.generic-array]
+version = "1.3.3"
+features = ["zeroize"]
+
 [dependencies.nssa]
 path = "../nssa"

common/src/rpc_primitives/requests.rs

@@ -1,8 +1,11 @@
+use std::collections::HashMap;
+
 use crate::parse_request;
 
 use super::errors::RpcParseError;
 use super::parser::RpcRequest;
 use super::parser::parse_params;
+use nssa_core::program::ProgramId;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -58,6 +61,9 @@ pub struct GetProofForCommitmentRequest {
     pub commitment: nssa_core::Commitment,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GetProgramIdsRequest {}
+
 parse_request!(HelloRequest);
 parse_request!(RegisterAccountRequest);
 parse_request!(SendTxRequest);
@@ -70,6 +76,7 @@ parse_request!(GetTransactionByHashRequest);
 parse_request!(GetAccountsNoncesRequest);
 parse_request!(GetProofForCommitmentRequest);
 parse_request!(GetAccountRequest);
+parse_request!(GetProgramIdsRequest);
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct HelloResponse {
@@ -126,3 +133,8 @@ pub struct GetAccountResponse {
 pub struct GetProofForCommitmentResponse {
     pub membership_proof: Option<nssa_core::MembershipProof>,
 }
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GetProgramIdsResponse {
+    pub program_ids: HashMap<String, ProgramId>,
+}

common/src/sequencer_client/mod.rs

@@ -1,16 +1,19 @@
+use std::collections::HashMap;
+
 use super::rpc_primitives::requests::{
     GetAccountBalanceRequest, GetAccountBalanceResponse, GetBlockDataRequest, GetBlockDataResponse,
     GetGenesisIdRequest, GetGenesisIdResponse, GetInitialTestnetAccountsRequest,
 };
 use anyhow::Result;
 use json::{SendTxRequest, SendTxResponse, SequencerRpcRequest, SequencerRpcResponse};
+use nssa_core::program::ProgramId;
 use reqwest::Client;
 use serde_json::Value;
 
 use crate::rpc_primitives::requests::{
     GetAccountRequest, GetAccountResponse, GetAccountsNoncesRequest, GetAccountsNoncesResponse,
-    GetProofForCommitmentRequest, GetProofForCommitmentResponse, GetTransactionByHashRequest,
-    GetTransactionByHashResponse,
+    GetProgramIdsRequest, GetProgramIdsResponse, GetProofForCommitmentRequest,
+    GetProofForCommitmentResponse, GetTransactionByHashRequest, GetTransactionByHashResponse,
 };
 use crate::sequencer_client::json::AccountInitialData;
 use crate::transaction::{EncodedTransaction, NSSATransaction};
@@ -256,4 +259,24 @@ impl SequencerClient {
 
         Ok(resp_deser)
     }
+
+    /// Get Ids of the programs used by the node
+    pub async fn get_program_ids(
+        &self,
+    ) -> Result<HashMap<String, ProgramId>, SequencerClientError> {
+        let acc_req = GetProgramIdsRequest {};
+
+        let req = serde_json::to_value(acc_req).unwrap();
+
+        let resp = self
+            .call_method_with_payload("get_program_ids", req)
+            .await
+            .unwrap();
+
+        let resp_deser = serde_json::from_value::<GetProgramIdsResponse>(resp)
+            .unwrap()
+            .program_ids;
+
+        Ok(resp_deser)
+    }
 }

integration_tests/Cargo.toml

@@ -36,3 +36,4 @@ path = "../common"
 
 [dependencies.nssa]
 path = "../nssa"
+features = ["no_docker"]

integration_tests/src/lib.rs

@@ -19,6 +19,10 @@ use tempfile::TempDir;
 use tokio::task::JoinHandle;
 use wallet::{
     Command, SubcommandReturnValue, WalletCore,
+    cli::token_program::{
+        TokenProgramSubcommand, TokenProgramSubcommandDeshielded, TokenProgramSubcommandPrivate,
+        TokenProgramSubcommandPublic, TokenProgramSubcommandShielded,
+    },
     config::PersistentAccountData,
     helperfunctions::{fetch_config, fetch_persistent_accounts},
 };
@@ -352,13 +356,15 @@ pub async fn test_success_token_program() {
         .expect("Failed to produce new account, not present in persistent accounts");
 
     // Create new token
-    let command = Command::CreateNewToken {
+    let subcommand = TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::CreateNewToken {
         definition_addr: definition_addr.to_string(),
         supply_addr: supply_addr.to_string(),
         name: "A NAME".to_string(),
         total_supply: 37,
-    };
-    wallet::execute_subcommand(command).await.unwrap();
+    });
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
@@ -404,12 +410,14 @@ pub async fn test_success_token_program() {
     );
 
     // Transfer 7 tokens from `supply_acc` to the account at address `recipient_addr`
-    let command = Command::TransferToken {
+    let subcommand = TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::TransferToken {
         sender_addr: supply_addr.to_string(),
         recipient_addr: recipient_addr.to_string(),
         balance_to_move: 7,
-    };
-    wallet::execute_subcommand(command).await.unwrap();
+    });
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
@@ -449,6 +457,504 @@ pub async fn test_success_token_program() {
     );
 }
 
+/// This test creates a new private token using the token program. After creating the token, the test executes a
+/// private token transfer to a new account. All accounts are owned except definition.
+pub async fn test_success_token_program_private_owned() {
+    let wallet_config = fetch_config().unwrap();
+
+    // Create new account for the token definition (public)
+    let SubcommandReturnValue::RegisterAccount {
+        addr: definition_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPublic {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for the token supply holder (private)
+    let SubcommandReturnValue::RegisterAccount { addr: supply_addr } =
+        wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+            .await
+            .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for receiving a token transaction
+    let SubcommandReturnValue::RegisterAccount {
+        addr: recipient_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    // Create new token
+    let subcommand = TokenProgramSubcommand::Private(
+        TokenProgramSubcommandPrivate::CreateNewTokenPrivateOwned {
+            definition_addr: definition_addr.to_string(),
+            supply_addr: supply_addr.to_string(),
+            name: "A NAME".to_string(),
+            total_supply: 37,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+
+    // Check the status of the token definition account is the expected after the execution
+    let definition_acc = seq_client
+        .get_account(definition_addr.to_string())
+        .await
+        .unwrap()
+        .account;
+
+    assert_eq!(definition_acc.program_owner, Program::token().id());
+    // The data of a token definition account has the following layout:
+    // [ 0x00 || name (6 bytes) || total supply (little endian 16 bytes) ]
+    assert_eq!(
+        definition_acc.data,
+        vec![
+            0, 65, 32, 78, 65, 77, 69, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ]
+    );
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    // Transfer 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand =
+        TokenProgramSubcommand::Private(TokenProgramSubcommandPrivate::TransferTokenPrivateOwned {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        });
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    let new_commitment2 = wallet_storage
+        .get_private_account_commitment(&recipient_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await);
+
+    // Transfer additional 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand =
+        TokenProgramSubcommand::Private(TokenProgramSubcommandPrivate::TransferTokenPrivateOwned {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        });
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    let new_commitment2 = wallet_storage
+        .get_private_account_commitment(&recipient_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await);
+}
+
+/// This test creates a new private token using the token program. After creating the token, the test executes a
+/// private token transfer to a new account.
+pub async fn test_success_token_program_private_claiming_path() {
+    let wallet_config = fetch_config().unwrap();
+
+    // Create new account for the token definition (public)
+    let SubcommandReturnValue::RegisterAccount {
+        addr: definition_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPublic {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for the token supply holder (private)
+    let SubcommandReturnValue::RegisterAccount { addr: supply_addr } =
+        wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+            .await
+            .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for receiving a token transaction
+    let SubcommandReturnValue::RegisterAccount {
+        addr: recipient_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    // Create new token
+    let subcommand = TokenProgramSubcommand::Private(
+        TokenProgramSubcommandPrivate::CreateNewTokenPrivateOwned {
+            definition_addr: definition_addr.to_string(),
+            supply_addr: supply_addr.to_string(),
+            name: "A NAME".to_string(),
+            total_supply: 37,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+
+    // Check the status of the token definition account is the expected after the execution
+    let definition_acc = seq_client
+        .get_account(definition_addr.to_string())
+        .await
+        .unwrap()
+        .account;
+
+    assert_eq!(definition_acc.program_owner, Program::token().id());
+    // The data of a token definition account has the following layout:
+    // [ 0x00 || name (6 bytes) || total supply (little endian 16 bytes) ]
+    assert_eq!(
+        definition_acc.data,
+        vec![
+            0, 65, 32, 78, 65, 77, 69, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ]
+    );
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    let (recipient_keys, _) = wallet_storage
+        .storage
+        .user_data
+        .get_private_account(&recipient_addr)
+        .unwrap();
+
+    // Transfer 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand = TokenProgramSubcommand::Private(
+        TokenProgramSubcommandPrivate::TransferTokenPrivateForeign {
+            sender_addr: supply_addr.to_string(),
+            recipient_npk: hex::encode(recipient_keys.nullifer_public_key.0),
+            recipient_ipk: hex::encode(recipient_keys.incoming_viewing_public_key.0.clone()),
+            balance_to_move: 7,
+        },
+    );
+
+    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
+        wallet::execute_subcommand(Command::TokenProgram(subcommand))
+            .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;
+
+    let command = Command::FetchPrivateAccount {
+        tx_hash,
+        acc_addr: recipient_addr.to_string(),
+        output_id: 1,
+    };
+
+    wallet::execute_subcommand(command).await.unwrap();
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    let new_commitment2 = wallet_storage
+        .get_private_account_commitment(&recipient_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await);
+}
+
+/// This test creates a new public token using the token program. After creating the token, the test executes a
+/// shielded token transfer to a new account. All accounts are owned except definition.
+pub async fn test_success_token_program_shielded_owned() {
+    let wallet_config = fetch_config().unwrap();
+
+    // Create new account for the token definition (public)
+    let SubcommandReturnValue::RegisterAccount {
+        addr: definition_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPublic {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for the token supply holder (private)
+    let SubcommandReturnValue::RegisterAccount { addr: supply_addr } =
+        wallet::execute_subcommand(Command::RegisterAccountPublic {})
+            .await
+            .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for receiving a token transaction
+    let SubcommandReturnValue::RegisterAccount {
+        addr: recipient_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    // Create new token
+    let subcommand = TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::CreateNewToken {
+        definition_addr: definition_addr.to_string(),
+        supply_addr: supply_addr.to_string(),
+        name: "A NAME".to_string(),
+        total_supply: 37,
+    });
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+
+    // Check the status of the token definition account is the expected after the execution
+    let definition_acc = seq_client
+        .get_account(definition_addr.to_string())
+        .await
+        .unwrap()
+        .account;
+
+    assert_eq!(definition_acc.program_owner, Program::token().id());
+    // The data of a token definition account has the following layout:
+    // [ 0x00 || name (6 bytes) || total supply (little endian 16 bytes) ]
+    assert_eq!(
+        definition_acc.data,
+        vec![
+            0, 65, 32, 78, 65, 77, 69, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ]
+    );
+
+    // Transfer 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand = TokenProgramSubcommand::Shielded(
+        TokenProgramSubcommandShielded::TransferTokenShieldedOwned {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment2 = wallet_storage
+        .get_private_account_commitment(&recipient_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await);
+
+    // Transfer additional 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand = TokenProgramSubcommand::Shielded(
+        TokenProgramSubcommandShielded::TransferTokenShieldedOwned {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment2 = wallet_storage
+        .get_private_account_commitment(&recipient_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await);
+}
+
+/// This test creates a new private token using the token program. After creating the token, the test executes a
+/// deshielded token transfer to a new account. All accounts are owned except definition.
+pub async fn test_success_token_program_deshielded_owned() {
+    let wallet_config = fetch_config().unwrap();
+
+    // Create new account for the token definition (public)
+    let SubcommandReturnValue::RegisterAccount {
+        addr: definition_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPublic {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for the token supply holder (private)
+    let SubcommandReturnValue::RegisterAccount { addr: supply_addr } =
+        wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+            .await
+            .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+    // Create new account for receiving a token transaction
+    let SubcommandReturnValue::RegisterAccount {
+        addr: recipient_addr,
+    } = wallet::execute_subcommand(Command::RegisterAccountPublic {})
+        .await
+        .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    // Create new token
+    let subcommand = TokenProgramSubcommand::Private(
+        TokenProgramSubcommandPrivate::CreateNewTokenPrivateOwned {
+            definition_addr: definition_addr.to_string(),
+            supply_addr: supply_addr.to_string(),
+            name: "A NAME".to_string(),
+            total_supply: 37,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
+
+    // Check the status of the token definition account is the expected after the execution
+    let definition_acc = seq_client
+        .get_account(definition_addr.to_string())
+        .await
+        .unwrap()
+        .account;
+
+    assert_eq!(definition_acc.program_owner, Program::token().id());
+    // The data of a token definition account has the following layout:
+    // [ 0x00 || name (6 bytes) || total supply (little endian 16 bytes) ]
+    assert_eq!(
+        definition_acc.data,
+        vec![
+            0, 65, 32, 78, 65, 77, 69, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ]
+    );
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    // Transfer 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand = TokenProgramSubcommand::Deshielded(
+        TokenProgramSubcommandDeshielded::TransferTokenDeshielded {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+
+    // Transfer additional 7 tokens from `supply_acc` to the account at address `recipient_addr`
+    let subcommand = TokenProgramSubcommand::Deshielded(
+        TokenProgramSubcommandDeshielded::TransferTokenDeshielded {
+            sender_addr: supply_addr.to_string(),
+            recipient_addr: recipient_addr.to_string(),
+            balance_to_move: 7,
+        },
+    );
+
+    wallet::execute_subcommand(Command::TokenProgram(subcommand))
+        .await
+        .unwrap();
+
+    info!("Waiting for next block creation");
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let wallet_config = fetch_config().unwrap();
+    let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
+
+    let new_commitment1 = wallet_storage
+        .get_private_account_commitment(&supply_addr)
+        .unwrap();
+    assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await);
+}
+
 pub async fn test_success_private_transfer_to_another_owned_account() {
     info!("test_success_private_transfer_to_another_owned_account");
     let from: Address = ACC_SENDER_PRIVATE.parse().unwrap();
@@ -460,29 +966,11 @@ pub async fn test_success_private_transfer_to_another_owned_account() {
         amount: 100,
     };
 
-    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
-        wallet::execute_subcommand(command).await.unwrap()
-    else {
-        panic!("invalid subcommand return value");
-    };
+    wallet::execute_subcommand(command).await.unwrap();
 
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
-    let command = Command::FetchPrivateAccount {
-        tx_hash: tx_hash.clone(),
-        acc_addr: from.to_string(),
-        output_id: 0,
-    };
-    wallet::execute_subcommand(command).await.unwrap();
-
-    let command = Command::FetchPrivateAccount {
-        tx_hash,
-        acc_addr: to.to_string(),
-        output_id: 1,
-    };
-    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();
@@ -521,13 +1009,6 @@ pub async fn test_success_private_transfer_to_another_foreign_account() {
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
-    let command = Command::FetchPrivateAccount {
-        tx_hash: tx_hash.clone(),
-        acc_addr: from.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();
@@ -626,21 +1107,11 @@ pub async fn test_success_deshielded_transfer_to_another_account() {
     let from_acc = wallet_storage.get_account_private(&from).unwrap();
     assert_eq!(from_acc.balance, 10000);
 
-    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
-        wallet::execute_subcommand(command).await.unwrap()
-    else {
-        panic!("invalid subcommand return value");
-    };
+    wallet::execute_subcommand(command).await.unwrap();
 
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
-    let command = Command::FetchPrivateAccount {
-        tx_hash,
-        acc_addr: from.to_string(),
-        output_id: 0,
-    };
-    wallet::execute_subcommand(command).await.unwrap();
     let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
 
     let from_acc = wallet_storage.get_account_private(&from).unwrap();
@@ -673,21 +1144,12 @@ pub async fn test_success_shielded_transfer_to_another_owned_account() {
     let wallet_config = fetch_config().unwrap();
     let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap();
 
-    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } =
-        wallet::execute_subcommand(command).await.unwrap()
-    else {
-        panic!("invalid subcommand return value");
-    };
+    wallet::execute_subcommand(command).await.unwrap();
 
     info!("Waiting for next block creation");
     tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
 
-    let command = Command::FetchPrivateAccount {
-        tx_hash,
-        acc_addr: to.to_string(),
-        output_id: 0,
-    };
-    wallet::execute_subcommand(command).await.unwrap();
+    let wallet_config = fetch_config().unwrap();
     let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap();
 
     let acc_to = wallet_storage.get_account_private(&to).unwrap();
@@ -831,6 +1293,124 @@ pub async fn test_program_deployment() {
     assert_eq!(post_state_account.balance, 0);
     assert_eq!(post_state_account.data, vec![0]);
     assert_eq!(post_state_account.nonce, 0);
+
+    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!");
+}
+
+pub async fn test_pinata_private_receiver_new_account() {
+    info!("test_pinata_private_receiver");
+    let pinata_addr = "cafe".repeat(16);
+    let pinata_prize = 150;
+    let solution = 989106;
+
+    // Create new account for the token supply holder (private)
+    let SubcommandReturnValue::RegisterAccount { addr: winner_addr } =
+        wallet::execute_subcommand(Command::RegisterAccountPrivate {})
+            .await
+            .unwrap()
+    else {
+        panic!("invalid subcommand return value");
+    };
+
+    let command = Command::ClaimPinataPrivateReceiverOwned {
+        pinata_addr: pinata_addr.clone(),
+        winner_addr: winner_addr.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;
+
+    wallet::execute_subcommand(command).await.unwrap();
+
+    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 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(&winner_addr)
+        .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 {
@@ -916,6 +1496,24 @@ pub async fn main_tests_runner() -> Result<()> {
         "test_program_deployment" => {
             test_cleanup_wrap!(home_dir, test_program_deployment);
         }
+        "test_pinata_private_receiver" => {
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver);
+        }
+        "test_success_token_program_private_owned" => {
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_owned);
+        }
+        "test_success_token_program_private_claiming_path" => {
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_claiming_path);
+        }
+        "test_pinata_private_receiver_new_account" => {
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account);
+        }
+        "test_success_token_program_shielded_owned" => {
+            test_cleanup_wrap!(home_dir, test_success_token_program_shielded_owned);
+        }
+        "test_success_token_program_deshielded_owned" => {
+            test_cleanup_wrap!(home_dir, test_success_token_program_deshielded_owned);
+        }
         "all" => {
             test_cleanup_wrap!(home_dir, test_success_move_to_another_account);
             test_cleanup_wrap!(home_dir, test_success);
@@ -948,6 +1546,10 @@ pub async fn main_tests_runner() -> Result<()> {
             );
             test_cleanup_wrap!(home_dir, test_pinata);
             test_cleanup_wrap!(home_dir, test_program_deployment);
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver);
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_owned);
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_claiming_path);
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account);
         }
         "all_private" => {
             test_cleanup_wrap!(
@@ -974,6 +1576,10 @@ pub async fn main_tests_runner() -> Result<()> {
                 home_dir,
                 test_success_private_transfer_to_another_owned_account_claiming_path
             );
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver);
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_owned);
+            test_cleanup_wrap!(home_dir, test_success_token_program_private_claiming_path);
+            test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account);
         }
         _ => {
             anyhow::bail!("Unknown test name");

nssa/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 thiserror = "2.0.12"
 risc0-zkvm = { version = "3.0.3", features = ['std'] }
 nssa-core = { path = "core", features = ["host"] }
-program-methods = { path = "program_methods" }
+program-methods = { path = "program_methods", optional = true }
 serde = "1.0.219"
 sha2 = "0.10.9"
 secp256k1 = "0.31.1"
@@ -16,9 +16,14 @@ borsh = "1.5.7"
 hex = "0.4.3"
 risc0-binfmt = "3.0.2"
 
+[build-dependencies]
+risc0-build = "3.0.3"
+risc0-binfmt = "3.0.2"
+
 [dev-dependencies]
 test-program-methods = { path = "test_program_methods" }
 hex-literal = "1.0.0"
 
 [features]
 default = []
+no_docker = ["program-methods"]

nssa/build.rs

@@ -0,0 +1,63 @@
+fn main() {
+    if cfg!(feature = "no_docker") {
+        println!("cargo:warning=NO_DOCKER feature enabled – deterministic build skipped");
+        return;
+    }
+
+    build_deterministic().expect("Deterministic build failed");
+}
+
+fn build_deterministic() -> Result<(), Box<dyn std::error::Error>> {
+    use std::{env, fs, path::PathBuf, process::Command};
+
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
+    let mod_dir = out_dir.join("program_methods");
+    let mod_file = mod_dir.join("mod.rs");
+
+    println!("cargo:rerun-if-changed=program_methods/guest/src");
+    println!("cargo:rerun-if-changed=program_methods/guest/Cargo.toml");
+
+    let guest_manifest = manifest_dir.join("program_methods/guest/Cargo.toml");
+
+    let status = Command::new("cargo")
+        .args(["risczero", "build", "--manifest-path"])
+        .arg(&guest_manifest)
+        .status()?;
+    if !status.success() {
+        return Err("Risc0 deterministic build failed".into());
+    }
+
+    let target_dir =
+        manifest_dir.join("program_methods/guest/target/riscv32im-risc0-zkvm-elf/docker/");
+
+    let bins = fs::read_dir(&target_dir)?
+        .filter_map(Result::ok)
+        .filter(|e| e.path().extension().is_some_and(|ext| ext == "bin"))
+        .collect::<Vec<_>>();
+
+    if bins.is_empty() {
+        return Err(format!("No .bin files found in {:?}", target_dir).into());
+    }
+
+    fs::create_dir_all(&mod_dir)?;
+    let mut src = String::new();
+    for entry in bins {
+        let path = entry.path();
+        let name = path.file_stem().unwrap().to_string_lossy();
+        let bytecode = fs::read(&path)?;
+        let image_id: [u32; 8] = risc0_binfmt::compute_image_id(&bytecode)?.into();
+        src.push_str(&format!(
+            "pub const {}_ELF: &[u8] = include_bytes!(r#\"{}\"#);\n\
+             pub const {}_ID: [u32; 8] = {:?};\n",
+            name.to_uppercase(),
+            path.display(),
+            name.to_uppercase(),
+            image_id
+        ));
+    }
+    fs::write(&mod_file, src)?;
+    println!("cargo:warning=Generated module at {}", mod_file.display());
+
+    Ok(())
+}

nssa/src/lib.rs

@@ -1,3 +1,12 @@
+#[cfg(not(feature = "no_docker"))]
+pub mod program_methods {
+    include!(concat!(env!("OUT_DIR"), "/program_methods/mod.rs"));
+}
+
+#[cfg(feature = "no_docker")]
+#[allow(clippy::single_component_path_imports)]
+use program_methods;
+
 pub mod encoding;
 pub mod error;
 mod merkle_tree;
@@ -14,6 +23,7 @@ pub use privacy_preserving_transaction::{
     PrivacyPreservingTransaction, circuit::execute_and_prove,
 };
 pub use program_deployment_transaction::ProgramDeploymentTransaction;
+pub use program_methods::PRIVACY_PRESERVING_CIRCUIT_ID;
 pub use public_transaction::PublicTransaction;
 pub use signature::PrivateKey;
 pub use signature::PublicKey;

nssa/src/privacy_preserving_transaction/circuit.rs

@@ -8,7 +8,7 @@ use risc0_zkvm::{ExecutorEnv, InnerReceipt, Receipt, default_prover};
 
 use crate::{error::NssaError, program::Program};
 
-use program_methods::{PRIVACY_PRESERVING_CIRCUIT_ELF, PRIVACY_PRESERVING_CIRCUIT_ID};
+use crate::program_methods::{PRIVACY_PRESERVING_CIRCUIT_ELF, PRIVACY_PRESERVING_CIRCUIT_ID};
 
 /// Proof of the privacy preserving execution circuit
 #[derive(Debug, Clone, PartialEq, Eq)]

nssa/src/program.rs

@@ -1,8 +1,9 @@
+use crate::program_methods::{AUTHENTICATED_TRANSFER_ELF, PINATA_ELF, TOKEN_ELF};
 use nssa_core::{
     account::{Account, AccountWithMetadata},
     program::{InstructionData, ProgramId, ProgramOutput},
 };
-use program_methods::{AUTHENTICATED_TRANSFER_ELF, PINATA_ELF, TOKEN_ELF};
+
 use risc0_zkvm::{ExecutorEnv, ExecutorEnvBuilder, default_executor, serde::to_vec};
 use serde::Serialize;
 

sequencer_rpc/src/process.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use actix_web::Error as HttpError;
 use base64::{Engine, engine::general_purpose};
-use nssa;
+use nssa::{self, program::Program};
 use sequencer_core::config::AccountInitialData;
 use serde_json::Value;
 
@@ -14,9 +16,9 @@ use common::{
         requests::{
             GetAccountBalanceRequest, GetAccountBalanceResponse, GetAccountRequest,
             GetAccountResponse, GetAccountsNoncesRequest, GetAccountsNoncesResponse,
-            GetInitialTestnetAccountsRequest, GetProofForCommitmentRequest,
-            GetProofForCommitmentResponse, GetTransactionByHashRequest,
-            GetTransactionByHashResponse,
+            GetInitialTestnetAccountsRequest, GetProgramIdsRequest, GetProgramIdsResponse,
+            GetProofForCommitmentRequest, GetProofForCommitmentResponse,
+            GetTransactionByHashRequest, GetTransactionByHashResponse,
         },
     },
     transaction::EncodedTransaction,
@@ -40,6 +42,7 @@ pub const GET_TRANSACTION_BY_HASH: &str = "get_transaction_by_hash";
 pub const GET_ACCOUNTS_NONCES: &str = "get_accounts_nonces";
 pub const GET_ACCOUNT: &str = "get_account";
 pub const GET_PROOF_FOR_COMMITMENT: &str = "get_proof_for_commitment";
+pub const GET_PROGRAM_IDS: &str = "get_program_ids";
 
 pub const HELLO_FROM_SEQUENCER: &str = "HELLO_FROM_SEQUENCER";
 
@@ -267,6 +270,24 @@ impl JsonHandler {
         respond(helperstruct)
     }
 
+    async fn process_get_program_ids(&self, request: Request) -> Result<Value, RpcErr> {
+        let _get_proof_req = GetProgramIdsRequest::parse(Some(request.params))?;
+
+        let mut program_ids = HashMap::new();
+        program_ids.insert(
+            "authenticated_transfer".to_string(),
+            Program::authenticated_transfer_program().id(),
+        );
+        program_ids.insert("token".to_string(), Program::token().id());
+        program_ids.insert("pinata".to_string(), Program::pinata().id());
+        program_ids.insert(
+            "privacy_preserving_circuit".to_string(),
+            nssa::PRIVACY_PRESERVING_CIRCUIT_ID,
+        );
+        let helperstruct = GetProgramIdsResponse { program_ids };
+        respond(helperstruct)
+    }
+
     pub async fn process_request_internal(&self, request: Request) -> Result<Value, RpcErr> {
         match request.method.as_ref() {
             HELLO => self.process_temp_hello(request).await,
@@ -280,6 +301,7 @@ impl JsonHandler {
             GET_ACCOUNT => self.process_get_account(request).await,
             GET_TRANSACTION_BY_HASH => self.process_get_transaction_by_hash(request).await,
             GET_PROOF_FOR_COMMITMENT => self.process_get_proof_by_commitment(request).await,
+            GET_PROGRAM_IDS => self.process_get_program_ids(request).await,
             _ => Err(RpcErr(RpcError::method_not_found(request.method))),
         }
     }

wallet/src/cli/mod.rs

@@ -0,0 +1,10 @@
+use anyhow::Result;
+
+use crate::{SubcommandReturnValue, WalletCore};
+
+pub mod token_program;
+
+pub(crate) trait WalletSubcommand {
+    async fn handle_subcommand(self, wallet_core: &mut WalletCore)
+    -> Result<SubcommandReturnValue>;
+}

wallet/src/cli/token_program.rs

@@ -0,0 +1,518 @@
+use anyhow::Result;
+use clap::Subcommand;
+use common::transaction::NSSATransaction;
+use nssa::Address;
+
+use crate::{SubcommandReturnValue, WalletCore, cli::WalletSubcommand};
+
+///Represents generic CLI subcommand for a wallet working with token_program
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenProgramSubcommand {
+    ///Public execution
+    #[command(subcommand)]
+    Public(TokenProgramSubcommandPublic),
+    ///Private execution
+    #[command(subcommand)]
+    Private(TokenProgramSubcommandPrivate),
+    ///Deshielded execution
+    #[command(subcommand)]
+    Deshielded(TokenProgramSubcommandDeshielded),
+    ///Shielded execution
+    #[command(subcommand)]
+    Shielded(TokenProgramSubcommandShielded),
+}
+
+///Represents generic public CLI subcommand for a wallet working with token_program
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenProgramSubcommandPublic {
+    //Create a new token using the token program
+    CreateNewToken {
+        #[arg(short, long)]
+        definition_addr: String,
+        #[arg(short, long)]
+        supply_addr: String,
+        #[arg(short, long)]
+        name: String,
+        #[arg(short, long)]
+        total_supply: u128,
+    },
+    //Transfer tokens using the token program
+    TransferToken {
+        #[arg(short, long)]
+        sender_addr: String,
+        #[arg(short, long)]
+        recipient_addr: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+}
+
+///Represents generic private CLI subcommand for a wallet working with token_program
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenProgramSubcommandPrivate {
+    //Create a new token using the token program
+    CreateNewTokenPrivateOwned {
+        #[arg(short, long)]
+        definition_addr: String,
+        #[arg(short, long)]
+        supply_addr: String,
+        #[arg(short, long)]
+        name: String,
+        #[arg(short, long)]
+        total_supply: u128,
+    },
+    //Transfer tokens using the token program
+    TransferTokenPrivateOwned {
+        #[arg(short, long)]
+        sender_addr: String,
+        #[arg(short, long)]
+        recipient_addr: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+    //Transfer tokens using the token program
+    TransferTokenPrivateForeign {
+        #[arg(short, long)]
+        sender_addr: String,
+        ///recipient_npk - valid 32 byte hex string
+        #[arg(long)]
+        recipient_npk: String,
+        ///recipient_ipk - valid 33 byte hex string
+        #[arg(long)]
+        recipient_ipk: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+}
+
+///Represents deshielded public CLI subcommand for a wallet working with token_program
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenProgramSubcommandDeshielded {
+    //Transfer tokens using the token program
+    TransferTokenDeshielded {
+        #[arg(short, long)]
+        sender_addr: String,
+        #[arg(short, long)]
+        recipient_addr: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+}
+
+///Represents generic shielded CLI subcommand for a wallet working with token_program
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenProgramSubcommandShielded {
+    //Transfer tokens using the token program
+    TransferTokenShieldedOwned {
+        #[arg(short, long)]
+        sender_addr: String,
+        #[arg(short, long)]
+        recipient_addr: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+    //Transfer tokens using the token program
+    TransferTokenShieldedForeign {
+        #[arg(short, long)]
+        sender_addr: String,
+        ///recipient_npk - valid 32 byte hex string
+        #[arg(long)]
+        recipient_npk: String,
+        ///recipient_ipk - valid 33 byte hex string
+        #[arg(long)]
+        recipient_ipk: String,
+        #[arg(short, long)]
+        balance_to_move: u128,
+    },
+}
+
+impl WalletSubcommand for TokenProgramSubcommandPublic {
+    async fn handle_subcommand(
+        self,
+        wallet_core: &mut WalletCore,
+    ) -> Result<SubcommandReturnValue> {
+        match self {
+            TokenProgramSubcommandPublic::CreateNewToken {
+                definition_addr,
+                supply_addr,
+                name,
+                total_supply,
+            } => {
+                let name = name.as_bytes();
+                if name.len() > 6 {
+                    // TODO: return error
+                    panic!();
+                }
+                let mut name_bytes = [0; 6];
+                name_bytes[..name.len()].copy_from_slice(name);
+                wallet_core
+                    .send_new_token_definition(
+                        definition_addr.parse().unwrap(),
+                        supply_addr.parse().unwrap(),
+                        name_bytes,
+                        total_supply,
+                    )
+                    .await?;
+                Ok(SubcommandReturnValue::Empty)
+            }
+            TokenProgramSubcommandPublic::TransferToken {
+                sender_addr,
+                recipient_addr,
+                balance_to_move,
+            } => {
+                wallet_core
+                    .send_transfer_token_transaction(
+                        sender_addr.parse().unwrap(),
+                        recipient_addr.parse().unwrap(),
+                        balance_to_move,
+                    )
+                    .await?;
+                Ok(SubcommandReturnValue::Empty)
+            }
+        }
+    }
+}
+
+impl WalletSubcommand for TokenProgramSubcommandPrivate {
+    async fn handle_subcommand(
+        self,
+        wallet_core: &mut WalletCore,
+    ) -> Result<SubcommandReturnValue> {
+        match self {
+            TokenProgramSubcommandPrivate::CreateNewTokenPrivateOwned {
+                definition_addr,
+                supply_addr,
+                name,
+                total_supply,
+            } => {
+                let name = name.as_bytes();
+                if name.len() > 6 {
+                    // TODO: return error
+                    panic!("Name length mismatch");
+                }
+                let mut name_bytes = [0; 6];
+                name_bytes[..name.len()].copy_from_slice(name);
+
+                let definition_addr: Address = definition_addr.parse().unwrap();
+                let supply_addr: Address = supply_addr.parse().unwrap();
+
+                let (res, [secret_supply]) = wallet_core
+                    .send_new_token_definition_private_owned(
+                        definition_addr,
+                        supply_addr,
+                        name_bytes,
+                        total_supply,
+                    )
+                    .await?;
+
+                println!("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 acc_decode_data = vec![(secret_supply, supply_addr)];
+
+                    wallet_core.decode_insert_privacy_preserving_transaction_results(
+                        tx,
+                        &acc_decode_data,
+                    )?;
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+            TokenProgramSubcommandPrivate::TransferTokenPrivateOwned {
+                sender_addr,
+                recipient_addr,
+                balance_to_move,
+            } => {
+                let sender_addr: Address = sender_addr.parse().unwrap();
+                let recipient_addr: Address = recipient_addr.parse().unwrap();
+
+                let recipient_initialization = wallet_core
+                    .check_private_account_initialized(&recipient_addr)
+                    .await?;
+
+                let (res, [secret_sender, secret_recipient]) =
+                    if let Some(recipient_proof) = recipient_initialization {
+                        wallet_core
+                        .send_transfer_token_transaction_private_owned_account_already_initialized(
+                            sender_addr,
+                            recipient_addr,
+                            balance_to_move,
+                            recipient_proof,
+                        )
+                        .await?
+                    } else {
+                        wallet_core
+                            .send_transfer_token_transaction_private_owned_account_not_initialized(
+                                sender_addr,
+                                recipient_addr,
+                                balance_to_move,
+                            )
+                            .await?
+                    };
+
+                println!("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 acc_decode_data = vec![
+                        (secret_sender, sender_addr),
+                        (secret_recipient, recipient_addr),
+                    ];
+
+                    wallet_core.decode_insert_privacy_preserving_transaction_results(
+                        tx,
+                        &acc_decode_data,
+                    )?;
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+            TokenProgramSubcommandPrivate::TransferTokenPrivateForeign {
+                sender_addr,
+                recipient_npk,
+                recipient_ipk,
+                balance_to_move,
+            } => {
+                let sender_addr: Address = sender_addr.parse().unwrap();
+                let recipient_npk_res = hex::decode(recipient_npk)?;
+                let mut recipient_npk = [0; 32];
+                recipient_npk.copy_from_slice(&recipient_npk_res);
+                let recipient_npk = nssa_core::NullifierPublicKey(recipient_npk);
+
+                let recipient_ipk_res = hex::decode(recipient_ipk)?;
+                let mut recipient_ipk = [0u8; 33];
+                recipient_ipk.copy_from_slice(&recipient_ipk_res);
+                let recipient_ipk = nssa_core::encryption::shared_key_derivation::Secp256k1Point(
+                    recipient_ipk.to_vec(),
+                );
+
+                let (res, [secret_sender, _]) = wallet_core
+                    .send_transfer_token_transaction_private_foreign_account(
+                        sender_addr,
+                        recipient_npk,
+                        recipient_ipk,
+                        balance_to_move,
+                    )
+                    .await?;
+
+                println!("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 acc_decode_data = vec![(secret_sender, sender_addr)];
+
+                    wallet_core.decode_insert_privacy_preserving_transaction_results(
+                        tx,
+                        &acc_decode_data,
+                    )?;
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+        }
+    }
+}
+
+impl WalletSubcommand for TokenProgramSubcommandDeshielded {
+    async fn handle_subcommand(
+        self,
+        wallet_core: &mut WalletCore,
+    ) -> Result<SubcommandReturnValue> {
+        match self {
+            TokenProgramSubcommandDeshielded::TransferTokenDeshielded {
+                sender_addr,
+                recipient_addr,
+                balance_to_move,
+            } => {
+                let sender_addr: Address = sender_addr.parse().unwrap();
+                let recipient_addr: Address = recipient_addr.parse().unwrap();
+
+                let (res, [secret_sender]) = wallet_core
+                    .send_transfer_token_transaction_deshielded(
+                        sender_addr,
+                        recipient_addr,
+                        balance_to_move,
+                    )
+                    .await?;
+
+                println!("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 acc_decode_data = vec![(secret_sender, sender_addr)];
+
+                    wallet_core.decode_insert_privacy_preserving_transaction_results(
+                        tx,
+                        &acc_decode_data,
+                    )?;
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+        }
+    }
+}
+
+impl WalletSubcommand for TokenProgramSubcommandShielded {
+    async fn handle_subcommand(
+        self,
+        wallet_core: &mut WalletCore,
+    ) -> Result<SubcommandReturnValue> {
+        match self {
+            TokenProgramSubcommandShielded::TransferTokenShieldedForeign {
+                sender_addr,
+                recipient_npk,
+                recipient_ipk,
+                balance_to_move,
+            } => {
+                let sender_addr: Address = sender_addr.parse().unwrap();
+                let recipient_npk_res = hex::decode(recipient_npk)?;
+                let mut recipient_npk = [0; 32];
+                recipient_npk.copy_from_slice(&recipient_npk_res);
+                let recipient_npk = nssa_core::NullifierPublicKey(recipient_npk);
+
+                let recipient_ipk_res = hex::decode(recipient_ipk)?;
+                let mut recipient_ipk = [0u8; 33];
+                recipient_ipk.copy_from_slice(&recipient_ipk_res);
+                let recipient_ipk = nssa_core::encryption::shared_key_derivation::Secp256k1Point(
+                    recipient_ipk.to_vec(),
+                );
+
+                let res = wallet_core
+                    .send_transfer_token_transaction_shielded_foreign_account(
+                        sender_addr,
+                        recipient_npk,
+                        recipient_ipk,
+                        balance_to_move,
+                    )
+                    .await?;
+
+                println!("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 {
+                    println!("Transaction data is {:?}", tx.message);
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+            TokenProgramSubcommandShielded::TransferTokenShieldedOwned {
+                sender_addr,
+                recipient_addr,
+                balance_to_move,
+            } => {
+                let sender_addr: Address = sender_addr.parse().unwrap();
+                let recipient_addr: Address = recipient_addr.parse().unwrap();
+
+                let recipient_initialization = wallet_core
+                    .check_private_account_initialized(&recipient_addr)
+                    .await?;
+
+                let (res, [secret_recipient]) =
+                    if let Some(recipient_proof) = recipient_initialization {
+                        wallet_core
+                        .send_transfer_token_transaction_shielded_owned_account_already_initialized(
+                            sender_addr,
+                            recipient_addr,
+                            balance_to_move,
+                            recipient_proof,
+                        )
+                        .await?
+                    } else {
+                        wallet_core
+                            .send_transfer_token_transaction_shielded_owned_account_not_initialized(
+                                sender_addr,
+                                recipient_addr,
+                                balance_to_move,
+                            )
+                            .await?
+                    };
+
+                println!("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 acc_decode_data = vec![(secret_recipient, recipient_addr)];
+
+                    wallet_core.decode_insert_privacy_preserving_transaction_results(
+                        tx,
+                        &acc_decode_data,
+                    )?;
+                }
+
+                let path = wallet_core.store_persistent_accounts()?;
+
+                println!("Stored persistent accounts at {path:#?}");
+
+                Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash })
+            }
+        }
+    }
+}
+
+impl WalletSubcommand for TokenProgramSubcommand {
+    async fn handle_subcommand(
+        self,
+        wallet_core: &mut WalletCore,
+    ) -> Result<SubcommandReturnValue> {
+        match self {
+            TokenProgramSubcommand::Private(private_subcommand) => {
+                private_subcommand.handle_subcommand(wallet_core).await
+            }
+            TokenProgramSubcommand::Public(public_subcommand) => {
+                public_subcommand.handle_subcommand(wallet_core).await
+            }
+            TokenProgramSubcommand::Deshielded(deshielded_subcommand) => {
+                deshielded_subcommand.handle_subcommand(wallet_core).await
+            }
+            TokenProgramSubcommand::Shielded(shielded_subcommand) => {
+                shielded_subcommand.handle_subcommand(wallet_core).await
+            }
+        }
+    }
+}

wallet/src/lib.rs

@@ -2,8 +2,7 @@ use std::{fs::File, io::Write, path::PathBuf, str::FromStr, sync::Arc};
 
 use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 use common::{
-    ExecutionFailureKind,
-    sequencer_client::{SequencerClient, json::SendTxResponse},
+    sequencer_client::SequencerClient,
     transaction::{EncodedTransaction, NSSATransaction},
 };
 
@@ -11,12 +10,14 @@ use anyhow::Result;
 use chain_storage::WalletChainStore;
 use config::WalletConfig;
 use log::info;
-use nssa::{Account, Address};
+use nssa::{Account, Address, program::Program};
 
 use clap::{Parser, Subcommand};
-use nssa_core::Commitment;
+use nssa_core::{Commitment, MembershipProof};
 
+use crate::cli::WalletSubcommand;
 use crate::{
+    cli::token_program::TokenProgramSubcommand,
     helperfunctions::{
         HumanReadableAccount, fetch_config, fetch_persistent_accounts, get_home,
         produce_data_for_storage,
@@ -24,14 +25,15 @@ use crate::{
     poller::TxPoller,
 };
 
-//
-
 pub const HOME_DIR_ENV_VAR: &str = "NSSA_WALLET_HOME_DIR";
 
 pub mod chain_storage;
+pub mod cli;
 pub mod config;
 pub mod helperfunctions;
+pub mod pinata_interactions;
 pub mod poller;
+pub mod token_program_interactions;
 pub mod token_transfers;
 
 pub struct WalletCore {
@@ -87,81 +89,6 @@ impl WalletCore {
             .generate_new_privacy_preserving_transaction_key_chain()
     }
 
-    pub async fn claim_pinata(
-        &self,
-        pinata_addr: Address,
-        winner_addr: Address,
-        solution: u128,
-    ) -> Result<SendTxResponse, ExecutionFailureKind> {
-        let addresses = vec![pinata_addr, winner_addr];
-        let program_id = nssa::program::Program::pinata().id();
-        let message =
-            nssa::public_transaction::Message::try_new(program_id, addresses, vec![], solution)
-                .unwrap();
-
-        let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[]);
-        let tx = nssa::PublicTransaction::new(message, witness_set);
-
-        Ok(self.sequencer_client.send_tx_public(tx).await?)
-    }
-
-    pub async fn send_new_token_definition(
-        &self,
-        definition_address: Address,
-        supply_address: Address,
-        name: [u8; 6],
-        total_supply: u128,
-    ) -> Result<SendTxResponse, ExecutionFailureKind> {
-        let addresses = vec![definition_address, supply_address];
-        let program_id = nssa::program::Program::token().id();
-        // Instruction must be: [0x00 || total_supply (little-endian 16 bytes) || name (6 bytes)]
-        let mut instruction = [0; 23];
-        instruction[1..17].copy_from_slice(&total_supply.to_le_bytes());
-        instruction[17..].copy_from_slice(&name);
-        let message =
-            nssa::public_transaction::Message::try_new(program_id, addresses, vec![], instruction)
-                .unwrap();
-
-        let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[]);
-
-        let tx = nssa::PublicTransaction::new(message, witness_set);
-
-        Ok(self.sequencer_client.send_tx_public(tx).await?)
-    }
-
-    pub async fn send_transfer_token_transaction(
-        &self,
-        sender_address: Address,
-        recipient_address: Address,
-        amount: u128,
-    ) -> Result<SendTxResponse, ExecutionFailureKind> {
-        let addresses = vec![sender_address, recipient_address];
-        let program_id = nssa::program::Program::token().id();
-        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
-        let mut instruction = [0; 23];
-        instruction[0] = 0x01;
-        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
-        let Ok(nonces) = self.get_accounts_nonces(vec![sender_address]).await else {
-            return Err(ExecutionFailureKind::SequencerError);
-        };
-        let message =
-            nssa::public_transaction::Message::try_new(program_id, addresses, nonces, instruction)
-                .unwrap();
-
-        let Some(signing_key) = self
-            .storage
-            .user_data
-            .get_pub_account_signing_key(&sender_address)
-        else {
-            return Err(ExecutionFailureKind::KeyNotFoundError);
-        };
-        let witness_set =
-            nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]);
-
-        let tx = nssa::PublicTransaction::new(message, witness_set);
-
-        Ok(self.sequencer_client.send_tx_public(tx).await?)
-    }
     ///Get account balance
     pub async fn get_account_balance(&self, acc: Address) -> Result<u128> {
         Ok(self
@@ -207,6 +134,48 @@ impl WalletCore {
 
         Ok(NSSATransaction::try_from(&pub_tx)?)
     }
+
+    pub async fn check_private_account_initialized(
+        &self,
+        addr: &Address,
+    ) -> Result<Option<MembershipProof>> {
+        if let Some(acc_comm) = self.get_private_account_commitment(addr) {
+            self.sequencer_client
+                .get_proof_for_commitment(acc_comm)
+                .await
+                .map_err(anyhow::Error::from)
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn decode_insert_privacy_preserving_transaction_results(
+        &mut self,
+        tx: nssa::privacy_preserving_transaction::PrivacyPreservingTransaction,
+        acc_decode_data: &[(nssa_core::SharedSecretKey, Address)],
+    ) -> Result<()> {
+        for (output_index, (secret, acc_address)) in acc_decode_data.iter().enumerate() {
+            let acc_ead = tx.message.encrypted_private_post_states[output_index].clone();
+            let acc_comm = tx.message.new_commitments[output_index].clone();
+
+            let res_acc = nssa_core::EncryptionScheme::decrypt(
+                &acc_ead.ciphertext,
+                secret,
+                &acc_comm,
+                output_index as u32,
+            )
+            .unwrap();
+
+            println!("Received new acc {res_acc:#?}");
+
+            self.storage
+                .insert_private_account_data(*acc_address, res_acc);
+        }
+
+        println!("Transaction data is {:?}", tx.message);
+
+        Ok(())
+    }
 }
 
 ///Represents CLI command for a wallet
@@ -344,26 +313,6 @@ pub enum Command {
         #[arg(short, long)]
         addr: String,
     },
-    //Create a new token using the token program
-    CreateNewToken {
-        #[arg(short, long)]
-        definition_addr: String,
-        #[arg(short, long)]
-        supply_addr: String,
-        #[arg(short, long)]
-        name: String,
-        #[arg(short, long)]
-        total_supply: u128,
-    },
-    //Transfer tokens using the token program
-    TransferToken {
-        #[arg(short, long)]
-        sender_addr: String,
-        #[arg(short, long)]
-        recipient_addr: String,
-        #[arg(short, long)]
-        balance_to_move: u128,
-    },
     // TODO: Testnet only. Refactor to prevent compilation on mainnet.
     // Claim piñata prize
     ClaimPinata {
@@ -377,6 +326,25 @@ pub enum Command {
         #[arg(long)]
         solution: u128,
     },
+    // Check the wallet can connect to the node and builtin local programs
+    // match the remote versions
+    CheckHealth {},
+    // 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,
+    },
+    ///Token command
+    #[command(subcommand)]
+    TokenProgram(TokenProgramSubcommand),
 }
 
 ///To execute commands, env var NSSA_WALLET_HOME_DIR must be set into directory with config
@@ -437,39 +405,10 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
                 .await?;
 
             if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx {
-                let from_ebc = tx.message.encrypted_private_post_states[0].clone();
-                let from_comm = tx.message.new_commitments[0].clone();
-
-                let to_ebc = tx.message.encrypted_private_post_states[1].clone();
-                let to_comm = tx.message.new_commitments[1].clone();
-
-                let res_acc_from = nssa_core::EncryptionScheme::decrypt(
-                    &from_ebc.ciphertext,
-                    &secret_from,
-                    &from_comm,
-                    0,
-                )
-                .unwrap();
-
-                let res_acc_to = nssa_core::EncryptionScheme::decrypt(
-                    &to_ebc.ciphertext,
-                    &secret_to,
-                    &to_comm,
-                    1,
-                )
-                .unwrap();
-
-                println!("Received new from acc {res_acc_from:#?}");
-                println!("Received new to acc {res_acc_to:#?}");
-
-                println!("Transaction data is {:?}", tx.message);
+                let acc_decode_data = vec![(secret_from, from), (secret_to, to)];
 
                 wallet_core
-                    .storage
-                    .insert_private_account_data(from, res_acc_from);
-                wallet_core
-                    .storage
-                    .insert_private_account_data(to, res_acc_to);
+                    .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?;
             }
 
             let path = wallet_core.store_persistent_accounts()?;
@@ -496,7 +435,7 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
             let to_ipk =
                 nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec());
 
-            let (res, [secret_from, secret_to]) = wallet_core
+            let (res, [secret_from, _]) = wallet_core
                 .send_private_native_token_transfer_outer_account(from, to_npk, to_ipk, amount)
                 .await?;
 
@@ -508,36 +447,10 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
                 .await?;
 
             if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx {
-                let from_ebc = tx.message.encrypted_private_post_states[0].clone();
-                let from_comm = tx.message.new_commitments[0].clone();
-
-                let to_ebc = tx.message.encrypted_private_post_states[1].clone();
-                let to_comm = tx.message.new_commitments[1].clone();
-
-                let res_acc_from = nssa_core::EncryptionScheme::decrypt(
-                    &from_ebc.ciphertext,
-                    &secret_from,
-                    &from_comm,
-                    0,
-                )
-                .unwrap();
-
-                let res_acc_to = nssa_core::EncryptionScheme::decrypt(
-                    &to_ebc.ciphertext,
-                    &secret_to,
-                    &to_comm,
-                    1,
-                )
-                .unwrap();
-
-                println!("RES acc {res_acc_from:#?}");
-                println!("RES acc to {res_acc_to:#?}");
-
-                println!("Transaction data is {:?}", tx.message);
+                let acc_decode_data = vec![(secret_from, from)];
 
                 wallet_core
-                    .storage
-                    .insert_private_account_data(from, res_acc_from);
+                    .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?;
             }
 
             let path = wallet_core.store_persistent_accounts()?;
@@ -562,24 +475,10 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
                 .await?;
 
             if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx {
-                let from_ebc = tx.message.encrypted_private_post_states[0].clone();
-                let from_comm = tx.message.new_commitments[0].clone();
-
-                let res_acc_from = nssa_core::EncryptionScheme::decrypt(
-                    &from_ebc.ciphertext,
-                    &secret,
-                    &from_comm,
-                    0,
-                )
-                .unwrap();
-
-                println!("RES acc {res_acc_from:#?}");
-
-                println!("Transaction data is {:?}", tx.message);
+                let acc_decode_data = vec![(secret, from)];
 
                 wallet_core
-                    .storage
-                    .insert_private_account_data(from, res_acc_from);
+                    .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?;
             }
 
             let path = wallet_core.store_persistent_accounts()?;
@@ -604,16 +503,10 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
                 .await?;
 
             if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx {
-                let to_ebc = tx.message.encrypted_private_post_states[0].clone();
-                let to_comm = tx.message.new_commitments[0].clone();
+                let acc_decode_data = vec![(secret, to)];
 
-                let res_acc_to =
-                    nssa_core::EncryptionScheme::decrypt(&to_ebc.ciphertext, &secret, &to_comm, 0)
-                        .unwrap();
-
-                println!("RES acc to {res_acc_to:#?}");
-
-                println!("Transaction data is {:?}", tx.message);
+                wallet_core
+                    .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?;
             }
 
             let path = wallet_core.store_persistent_accounts()?;
@@ -641,29 +534,13 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
             let to_ipk =
                 nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec());
 
-            let (res, secret) = wallet_core
+            let (res, _) = wallet_core
                 .send_shielded_native_token_transfer_outer_account(from, to_npk, to_ipk, amount)
                 .await?;
 
             println!("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 to_ebc = tx.message.encrypted_private_post_states[0].clone();
-                let to_comm = tx.message.new_commitments[0].clone();
-
-                let res_acc_to =
-                    nssa_core::EncryptionScheme::decrypt(&to_ebc.ciphertext, &secret, &to_comm, 0)
-                        .unwrap();
-
-                println!("RES acc to {res_acc_to:#?}");
-
-                println!("Transaction data is {:?}", tx.message);
-            }
 
             let path = wallet_core.store_persistent_accounts()?;
 
@@ -794,43 +671,6 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
             }
             SubcommandReturnValue::Empty
         }
-        Command::CreateNewToken {
-            definition_addr,
-            supply_addr,
-            name,
-            total_supply,
-        } => {
-            let name = name.as_bytes();
-            if name.len() > 6 {
-                // TODO: return error
-                panic!();
-            }
-            let mut name_bytes = [0; 6];
-            name_bytes[..name.len()].copy_from_slice(name);
-            wallet_core
-                .send_new_token_definition(
-                    definition_addr.parse().unwrap(),
-                    supply_addr.parse().unwrap(),
-                    name_bytes,
-                    total_supply,
-                )
-                .await?;
-            SubcommandReturnValue::Empty
-        }
-        Command::TransferToken {
-            sender_addr,
-            recipient_addr,
-            balance_to_move,
-        } => {
-            wallet_core
-                .send_transfer_token_transaction(
-                    sender_addr.parse().unwrap(),
-                    recipient_addr.parse().unwrap(),
-                    balance_to_move,
-                )
-                .await?;
-            SubcommandReturnValue::Empty
-        }
         Command::ClaimPinata {
             pinata_addr,
             winner_addr,
@@ -847,6 +687,90 @@ pub async fn execute_subcommand(command: Command) -> Result<SubcommandReturnValu
 
             SubcommandReturnValue::Empty
         }
+        Command::CheckHealth {} => {
+            let remote_program_ids = wallet_core
+                .sequencer_client
+                .get_program_ids()
+                .await
+                .expect("Error fetching program ids");
+            let Some(authenticated_transfer_id) = remote_program_ids.get("authenticated_transfer")
+            else {
+                panic!("Missing authenticated transfer ID from remote");
+            };
+            if authenticated_transfer_id != &Program::authenticated_transfer_program().id() {
+                panic!("Local ID for authenticated transfer program is different from remote");
+            }
+            let Some(token_id) = remote_program_ids.get("token") else {
+                panic!("Missing token program ID from remote");
+            };
+            if token_id != &Program::token().id() {
+                panic!("Local ID for token program is different from remote");
+            }
+            let Some(circuit_id) = remote_program_ids.get("privacy_preserving_circuit") else {
+                panic!("Missing privacy preserving circuit ID from remote");
+            };
+            if circuit_id != &nssa::PRIVACY_PRESERVING_CIRCUIT_ID {
+                panic!("Local ID for privacy preserving circuit is different from remote");
+            }
+
+            println!("✅All looks good!");
+
+            SubcommandReturnValue::Empty
+        }
+        Command::ClaimPinataPrivateReceiverOwned {
+            pinata_addr,
+            winner_addr,
+            solution,
+        } => {
+            let pinata_addr = pinata_addr.parse().unwrap();
+            let winner_addr = winner_addr.parse().unwrap();
+
+            let winner_initialization = wallet_core
+                .check_private_account_initialized(&winner_addr)
+                .await?;
+
+            let (res, [secret_winner]) = if let Some(winner_proof) = winner_initialization {
+                wallet_core
+                    .claim_pinata_private_owned_account_already_initialized(
+                        pinata_addr,
+                        winner_addr,
+                        solution,
+                        winner_proof,
+                    )
+                    .await?
+            } else {
+                wallet_core
+                    .claim_pinata_private_owned_account_not_initialized(
+                        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 acc_decode_data = vec![(secret_winner, winner_addr)];
+
+                wallet_core
+                    .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?;
+            }
+
+            let path = wallet_core.store_persistent_accounts()?;
+
+            println!("Stored persistent accounts at {path:#?}");
+
+            SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }
+        }
+        Command::TokenProgram(token_subcommand) => {
+            token_subcommand.handle_subcommand(&mut wallet_core).await?
+        }
     };
 
     Ok(subcommand_ret)

wallet/src/pinata_interactions.rs

@@ -0,0 +1,168 @@
+use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse};
+use key_protocol::key_management::ephemeral_key_holder::EphemeralKeyHolder;
+use nssa::{Address, privacy_preserving_transaction::circuit};
+use nssa_core::{MembershipProof, SharedSecretKey, account::AccountWithMetadata};
+
+use crate::{WalletCore, helperfunctions::produce_random_nonces};
+
+impl WalletCore {
+    pub async fn claim_pinata(
+        &self,
+        pinata_addr: Address,
+        winner_addr: Address,
+        solution: u128,
+    ) -> Result<SendTxResponse, ExecutionFailureKind> {
+        let addresses = vec![pinata_addr, winner_addr];
+        let program_id = nssa::program::Program::pinata().id();
+        let message =
+            nssa::public_transaction::Message::try_new(program_id, addresses, vec![], solution)
+                .unwrap();
+
+        let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[]);
+        let tx = nssa::PublicTransaction::new(message, witness_set);
+
+        Ok(self.sequencer_client.send_tx_public(tx).await?)
+    }
+
+    pub async fn claim_pinata_private_owned_account_already_initialized(
+        &self,
+        pinata_addr: Address,
+        winner_addr: Address,
+        solution: u128,
+        winner_proof: MembershipProof,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Some((winner_keys, winner_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&winner_addr)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let pinata_acc = self.get_account_public(pinata_addr).await.unwrap();
+
+        let winner_npk = winner_keys.nullifer_public_key;
+        let winner_ipk = winner_keys.incoming_viewing_public_key;
+
+        let program = nssa::program::Program::pinata();
+
+        let pinata_pre = AccountWithMetadata::new(pinata_acc.clone(), false, pinata_addr);
+        let winner_pre = AccountWithMetadata::new(winner_acc.clone(), true, &winner_npk);
+
+        let eph_holder_winner = EphemeralKeyHolder::new(&winner_npk);
+        let shared_secret_winner = eph_holder_winner.calculate_shared_secret_sender(&winner_ipk);
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[pinata_pre, winner_pre],
+            &nssa::program::Program::serialize_instruction(solution).unwrap(),
+            &[0, 1],
+            &produce_random_nonces(1),
+            &[(winner_npk.clone(), shared_secret_winner.clone())],
+            &[(
+                winner_keys.private_key_holder.nullifier_secret_key,
+                winner_proof,
+            )],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![pinata_addr],
+                vec![],
+                vec![(
+                    winner_npk.clone(),
+                    winner_ipk.clone(),
+                    eph_holder_winner.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new(
+            message,
+            witness_set,
+        );
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_winner],
+        ))
+    }
+
+    pub async fn claim_pinata_private_owned_account_not_initialized(
+        &self,
+        pinata_addr: Address,
+        winner_addr: Address,
+        solution: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Some((winner_keys, winner_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&winner_addr)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let pinata_acc = self.get_account_public(pinata_addr).await.unwrap();
+
+        let winner_npk = winner_keys.nullifer_public_key;
+        let winner_ipk = winner_keys.incoming_viewing_public_key;
+
+        let program = nssa::program::Program::pinata();
+
+        let pinata_pre = AccountWithMetadata::new(pinata_acc.clone(), false, pinata_addr);
+        let winner_pre = AccountWithMetadata::new(winner_acc.clone(), false, &winner_npk);
+
+        let eph_holder_winner = EphemeralKeyHolder::new(&winner_npk);
+        let shared_secret_winner = eph_holder_winner.calculate_shared_secret_sender(&winner_ipk);
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[pinata_pre, winner_pre],
+            &nssa::program::Program::serialize_instruction(solution).unwrap(),
+            &[0, 2],
+            &produce_random_nonces(1),
+            &[(winner_npk.clone(), shared_secret_winner.clone())],
+            &[],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![pinata_addr],
+                vec![],
+                vec![(
+                    winner_npk.clone(),
+                    winner_ipk.clone(),
+                    eph_holder_winner.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new(
+            message,
+            witness_set,
+        );
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_winner],
+        ))
+    }
+}

wallet/src/token_program_interactions.rs

@@ -0,0 +1,772 @@
+use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse};
+use key_protocol::key_management::ephemeral_key_holder::EphemeralKeyHolder;
+use nssa::{Address, privacy_preserving_transaction::circuit, program::Program};
+use nssa_core::{
+    Commitment, MembershipProof, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata,
+    encryption::IncomingViewingPublicKey,
+};
+
+use crate::{WalletCore, helperfunctions::produce_random_nonces};
+
+impl WalletCore {
+    pub async fn send_new_token_definition(
+        &self,
+        definition_address: Address,
+        supply_address: Address,
+        name: [u8; 6],
+        total_supply: u128,
+    ) -> Result<SendTxResponse, ExecutionFailureKind> {
+        let addresses = vec![definition_address, supply_address];
+        let program_id = nssa::program::Program::token().id();
+        // Instruction must be: [0x00 || total_supply (little-endian 16 bytes) || name (6 bytes)]
+        let mut instruction = [0; 23];
+        instruction[1..17].copy_from_slice(&total_supply.to_le_bytes());
+        instruction[17..].copy_from_slice(&name);
+        let message =
+            nssa::public_transaction::Message::try_new(program_id, addresses, vec![], instruction)
+                .unwrap();
+
+        let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[]);
+
+        let tx = nssa::PublicTransaction::new(message, witness_set);
+
+        Ok(self.sequencer_client.send_tx_public(tx).await?)
+    }
+
+    pub async fn send_new_token_definition_private_owned(
+        &self,
+        definition_addr: Address,
+        supply_addr: Address,
+        name: [u8; 6],
+        total_supply: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Some((supply_keys, supply_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&supply_addr)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        //It makes more sence to have definition acc as public
+        let definition_acc = self.get_account_public(definition_addr).await.unwrap();
+
+        let supply_npk = supply_keys.nullifer_public_key;
+        let supply_ipk = supply_keys.incoming_viewing_public_key;
+
+        let program = nssa::program::Program::token();
+
+        let definition_pre =
+            AccountWithMetadata::new(definition_acc.clone(), false, definition_addr);
+        let supply_pre = AccountWithMetadata::new(supply_acc.clone(), false, &supply_npk);
+
+        let eph_holder_supply = EphemeralKeyHolder::new(&supply_npk);
+        let shared_secret_supply = eph_holder_supply.calculate_shared_secret_sender(&supply_ipk);
+
+        // Instruction must be: [0x00 || total_supply (little-endian 16 bytes) || name (6 bytes)]
+        let mut instruction = [0; 23];
+        instruction[1..17].copy_from_slice(&total_supply.to_le_bytes());
+        instruction[17..].copy_from_slice(&name);
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[definition_pre, supply_pre],
+            &nssa::program::Program::serialize_instruction(instruction).unwrap(),
+            &[0, 2],
+            &produce_random_nonces(1),
+            &[(supply_npk.clone(), shared_secret_supply.clone())],
+            &[],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![definition_addr],
+                vec![],
+                vec![(
+                    supply_npk.clone(),
+                    supply_ipk.clone(),
+                    eph_holder_supply.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_supply],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+    ) -> Result<SendTxResponse, ExecutionFailureKind> {
+        let addresses = vec![sender_address, recipient_address];
+        let program_id = nssa::program::Program::token().id();
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+        let Ok(nonces) = self.get_accounts_nonces(vec![sender_address]).await else {
+            return Err(ExecutionFailureKind::SequencerError);
+        };
+        let message =
+            nssa::public_transaction::Message::try_new(program_id, addresses, nonces, instruction)
+                .unwrap();
+
+        let Some(signing_key) = self
+            .storage
+            .user_data
+            .get_pub_account_signing_key(&sender_address)
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+        let witness_set =
+            nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]);
+
+        let tx = nssa::PublicTransaction::new(message, witness_set);
+
+        Ok(self.sequencer_client.send_tx_public(tx).await?)
+    }
+
+    pub async fn send_transfer_token_transaction_private_owned_account_already_initialized(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+        recipient_proof: MembershipProof,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
+        let Some((sender_keys, sender_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&sender_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some((recipient_keys, recipient_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&recipient_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let sender_npk = sender_keys.nullifer_public_key;
+        let sender_ipk = sender_keys.incoming_viewing_public_key;
+        let recipient_npk = recipient_keys.nullifer_public_key.clone();
+        let recipient_ipk = recipient_keys.incoming_viewing_public_key.clone();
+
+        let program = Program::token();
+
+        let sender_commitment = Commitment::new(&sender_npk, &sender_acc);
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, &sender_npk);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), true, &recipient_npk);
+
+        let eph_holder_sender = EphemeralKeyHolder::new(&sender_npk);
+        let shared_secret_sender = eph_holder_sender.calculate_shared_secret_sender(&sender_ipk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[1, 1],
+            &produce_random_nonces(2),
+            &[
+                (sender_npk.clone(), shared_secret_sender.clone()),
+                (recipient_npk.clone(), shared_secret_recipient.clone()),
+            ],
+            &[
+                (
+                    sender_keys.private_key_holder.nullifier_secret_key,
+                    self.sequencer_client
+                        .get_proof_for_commitment(sender_commitment)
+                        .await
+                        .unwrap()
+                        .unwrap(),
+                ),
+                (
+                    recipient_keys.private_key_holder.nullifier_secret_key,
+                    recipient_proof,
+                ),
+            ],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![],
+                vec![],
+                vec![
+                    (
+                        sender_npk.clone(),
+                        sender_ipk.clone(),
+                        eph_holder_sender.generate_ephemeral_public_key(),
+                    ),
+                    (
+                        recipient_npk.clone(),
+                        recipient_ipk.clone(),
+                        eph_holder_recipient.generate_ephemeral_public_key(),
+                    ),
+                ],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_sender, shared_secret_recipient],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_private_owned_account_not_initialized(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
+        let Some((sender_keys, sender_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&sender_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some((recipient_keys, recipient_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&recipient_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let sender_npk = sender_keys.nullifer_public_key;
+        let sender_ipk = sender_keys.incoming_viewing_public_key;
+        let recipient_npk = recipient_keys.nullifer_public_key.clone();
+        let recipient_ipk = recipient_keys.incoming_viewing_public_key.clone();
+
+        let program = Program::token();
+
+        let sender_commitment = Commitment::new(&sender_npk, &sender_acc);
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, &sender_npk);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), false, &recipient_npk);
+
+        let eph_holder_sender = EphemeralKeyHolder::new(&sender_npk);
+        let shared_secret_sender = eph_holder_sender.calculate_shared_secret_sender(&sender_ipk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[1, 2],
+            &produce_random_nonces(2),
+            &[
+                (sender_npk.clone(), shared_secret_sender.clone()),
+                (recipient_npk.clone(), shared_secret_recipient.clone()),
+            ],
+            &[(
+                sender_keys.private_key_holder.nullifier_secret_key,
+                self.sequencer_client
+                    .get_proof_for_commitment(sender_commitment)
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            )],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![],
+                vec![],
+                vec![
+                    (
+                        sender_npk.clone(),
+                        sender_ipk.clone(),
+                        eph_holder_sender.generate_ephemeral_public_key(),
+                    ),
+                    (
+                        recipient_npk.clone(),
+                        recipient_ipk.clone(),
+                        eph_holder_recipient.generate_ephemeral_public_key(),
+                    ),
+                ],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_sender, shared_secret_recipient],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_private_foreign_account(
+        &self,
+        sender_address: Address,
+        recipient_npk: NullifierPublicKey,
+        recipient_ipk: IncomingViewingPublicKey,
+        amount: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
+        let Some((sender_keys, sender_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&sender_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let recipient_acc = nssa_core::account::Account::default();
+
+        let sender_npk = sender_keys.nullifer_public_key;
+        let sender_ipk = sender_keys.incoming_viewing_public_key;
+
+        let program = Program::token();
+
+        let sender_commitment = Commitment::new(&sender_npk, &sender_acc);
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, &sender_npk);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), false, &recipient_npk);
+
+        let eph_holder_sender = EphemeralKeyHolder::new(&sender_npk);
+        let shared_secret_sender = eph_holder_sender.calculate_shared_secret_sender(&sender_ipk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[1, 2],
+            &produce_random_nonces(2),
+            &[
+                (sender_npk.clone(), shared_secret_sender.clone()),
+                (recipient_npk.clone(), shared_secret_recipient.clone()),
+            ],
+            &[(
+                sender_keys.private_key_holder.nullifier_secret_key,
+                self.sequencer_client
+                    .get_proof_for_commitment(sender_commitment)
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            )],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![],
+                vec![],
+                vec![
+                    (
+                        sender_npk.clone(),
+                        sender_ipk.clone(),
+                        eph_holder_sender.generate_ephemeral_public_key(),
+                    ),
+                    (
+                        recipient_npk.clone(),
+                        recipient_ipk.clone(),
+                        eph_holder_recipient.generate_ephemeral_public_key(),
+                    ),
+                ],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_sender, shared_secret_recipient],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_deshielded(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Some((sender_keys, sender_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&sender_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Ok(recipient_acc) = self.get_account_public(recipient_address).await else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let sender_npk = sender_keys.nullifer_public_key;
+        let sender_ipk = sender_keys.incoming_viewing_public_key;
+
+        let program = Program::token();
+
+        let sender_commitment = Commitment::new(&sender_npk, &sender_acc);
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, &sender_npk);
+        let recipient_pre =
+            AccountWithMetadata::new(recipient_acc.clone(), false, recipient_address);
+
+        let eph_holder_sender = EphemeralKeyHolder::new(&sender_npk);
+        let shared_secret_sender = eph_holder_sender.calculate_shared_secret_sender(&sender_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[1, 0],
+            &produce_random_nonces(1),
+            &[(sender_npk.clone(), shared_secret_sender.clone())],
+            &[(
+                sender_keys.private_key_holder.nullifier_secret_key,
+                self.sequencer_client
+                    .get_proof_for_commitment(sender_commitment)
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            )],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![recipient_address],
+                vec![],
+                vec![(
+                    sender_npk.clone(),
+                    sender_ipk.clone(),
+                    eph_holder_sender.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_sender],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_shielded_owned_account_already_initialized(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+        recipient_proof: MembershipProof,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Ok(sender_acc) = self.get_account_public(sender_address).await else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some(sender_priv_key) = self
+            .storage
+            .user_data
+            .get_pub_account_signing_key(&sender_address)
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some((recipient_keys, recipient_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&recipient_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let recipient_npk = recipient_keys.nullifer_public_key.clone();
+        let recipient_ipk = recipient_keys.incoming_viewing_public_key.clone();
+
+        let program = Program::token();
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, sender_address);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), true, &recipient_npk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[0, 1],
+            &produce_random_nonces(1),
+            &[(recipient_npk.clone(), shared_secret_recipient.clone())],
+            &[(
+                recipient_keys.private_key_holder.nullifier_secret_key,
+                recipient_proof,
+            )],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![sender_address],
+                vec![sender_acc.nonce],
+                vec![(
+                    recipient_npk.clone(),
+                    recipient_ipk.clone(),
+                    eph_holder_recipient.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[sender_priv_key],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_recipient],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_shielded_owned_account_not_initialized(
+        &self,
+        sender_address: Address,
+        recipient_address: Address,
+        amount: u128,
+    ) -> Result<(SendTxResponse, [SharedSecretKey; 1]), ExecutionFailureKind> {
+        let Ok(sender_acc) = self.get_account_public(sender_address).await else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some(sender_priv_key) = self
+            .storage
+            .user_data
+            .get_pub_account_signing_key(&sender_address)
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some((recipient_keys, recipient_acc)) = self
+            .storage
+            .user_data
+            .get_private_account(&recipient_address)
+            .cloned()
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let recipient_npk = recipient_keys.nullifer_public_key.clone();
+        let recipient_ipk = recipient_keys.incoming_viewing_public_key.clone();
+
+        let program = Program::token();
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, sender_address);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), false, &recipient_npk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[0, 2],
+            &produce_random_nonces(1),
+            &[(recipient_npk.clone(), shared_secret_recipient.clone())],
+            &[],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![sender_address],
+                vec![sender_acc.nonce],
+                vec![(
+                    recipient_npk.clone(),
+                    recipient_ipk.clone(),
+                    eph_holder_recipient.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[sender_priv_key],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok((
+            self.sequencer_client.send_tx_private(tx).await?,
+            [shared_secret_recipient],
+        ))
+    }
+
+    pub async fn send_transfer_token_transaction_shielded_foreign_account(
+        &self,
+        sender_address: Address,
+        recipient_npk: NullifierPublicKey,
+        recipient_ipk: IncomingViewingPublicKey,
+        amount: u128,
+    ) -> Result<SendTxResponse, ExecutionFailureKind> {
+        let Ok(sender_acc) = self.get_account_public(sender_address).await else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let Some(sender_priv_key) = self
+            .storage
+            .user_data
+            .get_pub_account_signing_key(&sender_address)
+        else {
+            return Err(ExecutionFailureKind::KeyNotFoundError);
+        };
+
+        let recipient_acc = nssa_core::account::Account::default();
+
+        let program = Program::token();
+
+        let sender_pre = AccountWithMetadata::new(sender_acc.clone(), true, sender_address);
+        let recipient_pre = AccountWithMetadata::new(recipient_acc.clone(), false, &recipient_npk);
+
+        let eph_holder_recipient = EphemeralKeyHolder::new(&recipient_npk);
+        let shared_secret_recipient =
+            eph_holder_recipient.calculate_shared_secret_sender(&recipient_ipk);
+
+        // Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
+        let mut instruction = [0; 23];
+        instruction[0] = 0x01;
+        instruction[1..17].copy_from_slice(&amount.to_le_bytes());
+
+        let (output, proof) = circuit::execute_and_prove(
+            &[sender_pre, recipient_pre],
+            &Program::serialize_instruction(instruction).unwrap(),
+            &[0, 2],
+            &produce_random_nonces(1),
+            &[(recipient_npk.clone(), shared_secret_recipient.clone())],
+            &[],
+            &program,
+        )
+        .unwrap();
+
+        let message =
+            nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output(
+                vec![sender_address],
+                vec![sender_acc.nonce],
+                vec![(
+                    recipient_npk.clone(),
+                    recipient_ipk.clone(),
+                    eph_holder_recipient.generate_ephemeral_public_key(),
+                )],
+                output,
+            )
+            .unwrap();
+
+        let witness_set =
+            nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message(
+                &message,
+                proof,
+                &[sender_priv_key],
+            );
+        let tx = nssa::PrivacyPreservingTransaction::new(message, witness_set);
+
+        Ok(self.sequencer_client.send_tx_private(tx).await?)
+    }
+}