refactor: use faucet program to manage faucet account

program_methods/guest/Cargo.toml

@@ -17,6 +17,7 @@ amm_core.workspace = true
 amm_program.workspace = true
 ata_core.workspace = true
 ata_program.workspace = true
+faucet_core.workspace = true
 vault_core.workspace = true
 risc0-zkvm.workspace = true
 serde = { workspace = true, default-features = false }

program_methods/guest/src/bin/authenticated_transfer.rs

@@ -1,6 +1,5 @@
 use authenticated_transfer_core::Instruction;
 use nssa_core::{
-    SYSTEM_FAUCET_ACCOUNT_ID,
     account::{Account, AccountWithMetadata},
     program::{
         AccountPostState, Claim, DEFAULT_PROGRAM_ID, ProgramInput, ProgramOutput, read_nssa_inputs,
@@ -26,13 +25,8 @@ fn transfer(
     recipient: AccountWithMetadata,
     balance_to_move: u128,
 ) -> Vec<AccountPostState> {
-    // Continue only if the sender has authorized this operation
-    // or it's the system faucet account which is allowed without authorization as it may be used
-    // only by sequencer.
-    assert!(
-        sender.is_authorized || sender.account_id == SYSTEM_FAUCET_ACCOUNT_ID,
-        "Sender must be authorized"
-    );
+    // Continue only if the sender has authorized this operation.
+    assert!(sender.is_authorized, "Sender must be authorized");
 
     // Create accounts post states, with updated balances
     let sender_post = {

program_methods/guest/src/bin/faucet.rs

@@ -0,0 +1,71 @@
+use faucet_core::Instruction;
+use nssa_core::program::{
+    AccountPostState, ChainedCall, ProgramInput, ProgramOutput, read_nssa_inputs,
+};
+
+fn unchanged_post_states(
+    pre_states: &[nssa_core::account::AccountWithMetadata],
+) -> Vec<AccountPostState> {
+    pre_states
+        .iter()
+        .map(|pre_state| AccountPostState::new(pre_state.account.clone()))
+        .collect()
+}
+
+fn main() {
+    let (
+        ProgramInput {
+            self_program_id,
+            caller_program_id,
+            pre_states,
+            instruction,
+        },
+        instruction_words,
+    ) = read_nssa_inputs::<Instruction>();
+
+    let pre_states_clone = pre_states.clone();
+    let post_states = unchanged_post_states(&pre_states_clone);
+
+    let chained_calls = match instruction {
+        Instruction::Transfer {
+            vault_program_id,
+            recipient_id,
+            amount,
+        } => {
+            let [faucet, recipient_vault] = pre_states
+                .try_into()
+                .expect("Transfer requires exactly 2 accounts");
+
+            assert_eq!(
+                faucet.account_id,
+                faucet_core::compute_faucet_account_id(self_program_id),
+                "First account must be faucet PDA"
+            );
+
+            let mut faucet_for_vault = faucet;
+            faucet_for_vault.is_authorized = true;
+
+            vec![
+                ChainedCall::new(
+                    vault_program_id,
+                    vec![faucet_for_vault, recipient_vault],
+                    &vault_core::Instruction::Transfer {
+                        recipient_id,
+                        amount,
+                    },
+                )
+                .with_pda_seeds(vec![faucet_core::compute_faucet_seed()]),
+            ]
+        }
+    };
+
+    ProgramOutput::new(
+        self_program_id,
+        caller_program_id,
+        instruction_words,
+        pre_states_clone,
+        post_states,
+    )
+    .with_chained_calls(chained_calls)
+    .write();
+}