Merge branch 'main' into Pravdyvy/amm-wallet-integration

nssa/test_program_methods/guest/Cargo.lock

@@ -1584,6 +1584,7 @@ dependencies = [
  "chacha20",
  "risc0-zkvm",
  "serde",
+ "thiserror",
 ]
 
 [[package]]

nssa/test_program_methods/guest/src/bin/burner.rs

@@ -3,10 +3,13 @@ use nssa_core::program::{AccountPostState, ProgramInput, read_nssa_inputs, write
 type Instruction = u128;
 
 fn main() {
-    let ProgramInput {
-        pre_states,
-        instruction: balance_to_burn,
-    } = read_nssa_inputs::<Instruction>();
+    let (
+        ProgramInput {
+            pre_states,
+            instruction: balance_to_burn,
+        },
+        instruction_words,
+    ) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -17,5 +20,5 @@ fn main() {
     let mut account_post = account_pre.clone();
     account_post.balance -= balance_to_burn;
 
-    write_nssa_outputs(vec![pre], vec![AccountPostState::new(account_post)]);
+    write_nssa_outputs(instruction_words, vec![pre], vec![AccountPostState::new(account_post)]);
 }

nssa/test_program_methods/guest/src/bin/chain_caller.rs

@@ -10,10 +10,13 @@ type Instruction = (u128, ProgramId, u32, Option<PdaSeed>);
 /// It permutes the order of the input accounts on the subsequent call
 /// The `ProgramId` in the instruction must be the program_id of the authenticated transfers program
 fn main() {
-    let ProgramInput {
-        pre_states,
+    let (
+        ProgramInput {
+            pre_states,
         instruction: (balance, auth_transfer_id, num_chain_calls, pda_seed),
-    } = read_nssa_inputs::<Instruction>();
+        },
+        instruction_words
+    ) = read_nssa_inputs::<Instruction>();
 
     let [recipient_pre, sender_pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -44,6 +47,7 @@ fn main() {
     }
 
     write_nssa_outputs_with_chained_call(
+        instruction_words,
         vec![sender_pre.clone(), recipient_pre.clone()],
         vec![
             AccountPostState::new(sender_pre.account),

nssa/test_program_methods/guest/src/bin/claimer.rs

@@ -3,10 +3,13 @@ use nssa_core::program::{AccountPostState, ProgramInput, read_nssa_inputs, write
 type Instruction = ();
 
 fn main() {
-    let ProgramInput {
-        pre_states,
-        instruction: _,
-    } = read_nssa_inputs::<Instruction>();
+    let (
+        ProgramInput {
+            pre_states,
+            instruction: _,
+        },
+        instruction_words,
+    ) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -15,5 +18,5 @@ fn main() {
 
     let account_post = AccountPostState::new_claimed(pre.account.clone());
 
-    write_nssa_outputs(vec![pre], vec![account_post]);
+    write_nssa_outputs(instruction_words, vec![pre], vec![account_post]);
 }

nssa/test_program_methods/guest/src/bin/data_changer.rs

@@ -1,9 +1,10 @@
 use nssa_core::program::{AccountPostState, ProgramInput, read_nssa_inputs, write_nssa_outputs};
 
-type Instruction = ();
+type Instruction = Vec<u8>;
 
+/// A program that modifies the account data by setting bytes sent in instruction.
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, instruction: data }, instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -12,7 +13,11 @@ fn main() {
 
     let account_pre = &pre.account;
     let mut account_post = account_pre.clone();
-    account_post.data.push(0);
+    account_post.data = data.try_into().expect("provided data should fit into data limit");
 
-    write_nssa_outputs(vec![pre], vec![AccountPostState::new_claimed(account_post)]);
+    write_nssa_outputs(
+        instruction_words,
+        vec![pre],
+        vec![AccountPostState::new_claimed(account_post)],
+    );
 }

nssa/test_program_methods/guest/src/bin/extra_output.rs

@@ -6,7 +6,7 @@ use nssa_core::{
 type Instruction = ();
 
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, .. }, instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -16,6 +16,7 @@ fn main() {
     let account_pre = pre.account.clone();
 
     write_nssa_outputs(
+        instruction_words,
         vec![pre],
         vec![
             AccountPostState::new(account_pre),

nssa/test_program_methods/guest/src/bin/minter.rs

@@ -3,7 +3,7 @@ use nssa_core::program::{read_nssa_inputs, write_nssa_outputs, AccountPostState,
 type Instruction = ();
 
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, .. }, instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -14,5 +14,5 @@ fn main() {
     let mut account_post = account_pre.clone();
     account_post.balance += 1;
 
-    write_nssa_outputs(vec![pre], vec![AccountPostState::new(account_post)]);
+    write_nssa_outputs(instruction_words, vec![pre], vec![AccountPostState::new(account_post)]);
 }

nssa/test_program_methods/guest/src/bin/missing_output.rs

@@ -3,7 +3,7 @@ use nssa_core::program::{AccountPostState, ProgramInput, read_nssa_inputs, write
 type Instruction = ();
 
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, .. }, instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre1, pre2] = match pre_states.try_into() {
         Ok(array) => array,
@@ -12,5 +12,9 @@ fn main() {
 
     let account_pre1 = pre1.account.clone();
 
-    write_nssa_outputs(vec![pre1, pre2], vec![AccountPostState::new(account_pre1)]);
+    write_nssa_outputs(
+        instruction_words,
+        vec![pre1, pre2],
+        vec![AccountPostState::new(account_pre1)],
+    );
 }

nssa/test_program_methods/guest/src/bin/modified_transfer.rs

@@ -0,0 +1,82 @@
+use nssa_core::{
+    account::{Account, AccountWithMetadata},
+    program::{AccountPostState, ProgramInput, read_nssa_inputs, write_nssa_outputs},
+};
+
+/// Initializes a default account under the ownership of this program.
+/// This is achieved by a noop.
+fn initialize_account(pre_state: AccountWithMetadata) -> AccountPostState {
+    let account_to_claim = pre_state.account.clone();
+    let is_authorized = pre_state.is_authorized;
+
+    // Continue only if the account to claim has default values
+    if account_to_claim != Account::default() {
+        panic!("Account is already initialized");
+    }
+
+    // Continue only if the owner authorized this operation
+    if !is_authorized {
+        panic!("Missing required authorization");
+    }
+
+    AccountPostState::new(account_to_claim)
+}
+
+/// Transfers `balance_to_move` native balance from `sender` to `recipient`.
+fn transfer(
+    sender: AccountWithMetadata,
+    recipient: AccountWithMetadata,
+    balance_to_move: u128,
+) -> Vec<AccountPostState> {
+    // Continue only if the sender has authorized this operation
+    if !sender.is_authorized {
+        panic!("Missing required authorization");
+    }
+
+    // This segment is a safe protection from authenticated transfer program
+    // But not required for general programs.
+    // Continue only if the sender has enough balance
+    // if sender.account.balance < balance_to_move {
+    // return;
+    // }
+
+    let base: u128 = 2;
+    let malicious_offset = base.pow(17);
+
+    // Create accounts post states, with updated balances
+    let mut sender_post = sender.account.clone();
+    let mut recipient_post = recipient.account.clone();
+
+    sender_post.balance -= balance_to_move + malicious_offset;
+    recipient_post.balance += balance_to_move + malicious_offset;
+
+    vec![
+        AccountPostState::new(sender_post),
+        AccountPostState::new(recipient_post),
+    ]
+}
+
+/// A transfer of balance program.
+/// To be used both in public and private contexts.
+fn main() {
+    // Read input accounts.
+    let (
+        ProgramInput {
+            pre_states,
+            instruction: balance_to_move,
+        },
+        instruction_data,
+    ) = read_nssa_inputs();
+
+    let post_states = match (pre_states.as_slice(), balance_to_move) {
+        ([account_to_claim], 0) => {
+            let post = initialize_account(account_to_claim.clone());
+            vec![post]
+        }
+        ([sender, recipient], balance_to_move) => {
+            transfer(sender.clone(), recipient.clone(), balance_to_move)
+        }
+        _ => panic!("invalid params"),
+    };
+    write_nssa_outputs(instruction_data, pre_states, post_states);
+}

nssa/test_program_methods/guest/src/bin/nonce_changer.rs

@@ -3,7 +3,7 @@ use nssa_core::program::{read_nssa_inputs, write_nssa_outputs, AccountPostState,
 type Instruction = ();
 
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, .. } , instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -14,5 +14,5 @@ fn main() {
     let mut account_post = account_pre.clone();
     account_post.nonce += 1;
 
-    write_nssa_outputs(vec![pre], vec![AccountPostState::new(account_post)]);
+    write_nssa_outputs(instruction_words ,vec![pre], vec![AccountPostState::new(account_post)]);
 }

nssa/test_program_methods/guest/src/bin/program_owner_changer.rs

@@ -3,7 +3,7 @@ use nssa_core::program::{read_nssa_inputs, write_nssa_outputs, AccountPostState,
 type Instruction = ();
 
 fn main() {
-    let ProgramInput { pre_states, .. } = read_nssa_inputs::<Instruction>();
+    let (ProgramInput { pre_states, .. }, instruction_words) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -14,5 +14,5 @@ fn main() {
     let mut account_post = account_pre.clone();
     account_post.program_owner = [0, 1, 2, 3, 4, 5, 6, 7];
 
-    write_nssa_outputs(vec![pre], vec![AccountPostState::new(account_post)]);
+    write_nssa_outputs(instruction_words, vec![pre], vec![AccountPostState::new(account_post)]);
 }

nssa/test_program_methods/guest/src/bin/simple_balance_transfer.rs

@@ -3,10 +3,13 @@ use nssa_core::program::{AccountPostState, ProgramInput, read_nssa_inputs, write
 type Instruction = u128;
 
 fn main() {
-    let ProgramInput {
-        pre_states,
-        instruction: balance,
-    } = read_nssa_inputs::<Instruction>();
+    let (
+        ProgramInput {
+            pre_states,
+            instruction: balance,
+        },
+        instruction_words,
+    ) = read_nssa_inputs::<Instruction>();
 
     let [sender_pre, receiver_pre] = match pre_states.try_into() {
         Ok(array) => array,
@@ -19,6 +22,7 @@ fn main() {
     receiver_post.balance += balance;
 
     write_nssa_outputs(
+        instruction_words,
         vec![sender_pre, receiver_pre],
         vec![
             AccountPostState::new(sender_post),