fix(ata): validate token dispatch and existing occupants

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+    "token/ids",
     "token/core",
     "token",
     "token/methods",

ata/core/src/lib.rs

@@ -15,7 +15,7 @@ pub enum Instruction {
     /// - Token definition account
     /// - Associated token account (default/uninitialized, or already initialized)
     ///
-    /// `token_program_id` is derived from `token_definition.account.program_owner`.
+    /// The downstream token program is the canonical token program wired by the ATA guest.
     Create { ata_program_id: ProgramId },
 
     /// Transfer tokens FROM owner's ATA to a recipient token holding account.
@@ -26,7 +26,7 @@ pub enum Instruction {
     /// - Sender ATA (owner's token holding)
     /// - Recipient token holding (must be initialized)
     ///
-    /// `token_program_id` is derived from `sender_ata.account.program_owner`.
+    /// The downstream token program is the canonical token program wired by the ATA guest.
     Transfer {
         ata_program_id: ProgramId,
         amount: u128,
@@ -40,7 +40,7 @@ pub enum Instruction {
     /// - Owner's ATA (the holding to burn from)
     /// - Token definition account
     ///
-    /// `token_program_id` is derived from `holder_ata.account.program_owner`.
+    /// The downstream token program is the canonical token program wired by the ATA guest.
     Burn {
         ata_program_id: ProgramId,
         amount: u128,

ata/methods/guest/Cargo.toml

@@ -15,6 +15,7 @@ nssa_core = { git = "https://github.com/logos-blockchain/logos-execution-zone.gi
 risc0-zkvm = { version = "=3.0.5", default-features = false }
 ata_core = { path = "../../core" }
 ata_program = { path = "../..", package = "ata_program" }
+token-ids = { path = "../../../token/ids" }
 token_core = { path = "../../../token/core" }
 serde = { version = "1.0", features = ["derive"] }
 borsh = "1.5"

ata/methods/guest/src/bin/ata.rs

@@ -24,6 +24,7 @@ mod ata {
             token_definition,
             ata_account,
             ata_program_id,
+            token_ids::TOKEN_ID,
         );
         Ok(SpelOutput::with_chained_calls(post_states, chained_calls))
     }
@@ -44,6 +45,7 @@ mod ata {
                 sender_ata,
                 recipient,
                 ata_program_id,
+                token_ids::TOKEN_ID,
                 amount,
             );
         Ok(SpelOutput::with_chained_calls(post_states, chained_calls))
@@ -64,6 +66,7 @@ mod ata {
                 holder_ata,
                 token_definition,
                 ata_program_id,
+                token_ids::TOKEN_ID,
                 amount,
             );
         Ok(SpelOutput::with_chained_calls(post_states, chained_calls))

ata/src/burn.rs

@@ -2,20 +2,24 @@ use nssa_core::{
     account::AccountWithMetadata,
     program::{AccountPostState, ChainedCall, ProgramId},
 };
-use token_core::TokenHolding;
 
 pub fn burn_from_associated_token_account(
     owner: AccountWithMetadata,
     holder_ata: AccountWithMetadata,
     token_definition: AccountWithMetadata,
     ata_program_id: ProgramId,
+    token_program_id: ProgramId,
     amount: u128,
 ) -> (Vec<AccountPostState>, Vec<ChainedCall>) {
-    let token_program_id = holder_ata.account.program_owner;
     assert!(owner.is_authorized, "Owner authorization is missing");
-    let definition_id = TokenHolding::try_from(&holder_ata.account.data)
-        .expect("Holder ATA must hold a valid token")
-        .definition_id();
+    let _definition =
+        crate::validation::canonical_token_definition(&token_definition, token_program_id);
+    let definition_id =
+        crate::validation::canonical_ata_holding(&holder_ata, token_program_id).definition_id();
+    assert_eq!(
+        definition_id, token_definition.account_id,
+        "Holder ATA token definition mismatch"
+    );
     let seed =
         ata_core::verify_ata_and_get_seed(&holder_ata, &owner, definition_id, ata_program_id);
 

ata/src/create.rs

@@ -8,12 +8,14 @@ pub fn create_associated_token_account(
     token_definition: AccountWithMetadata,
     ata_account: AccountWithMetadata,
     ata_program_id: ProgramId,
+    token_program_id: ProgramId,
 ) -> (Vec<AccountPostState>, Vec<ChainedCall>) {
     // No explicit owner authorization check is needed here: ATA creation is idempotent, so the
     // call itself may proceed without `owner.is_authorized`. If the owner account is still
     // default, the returned post-state will still carry `Claim::Authorized` so the runtime can
     // claim that owner account when needed.
-    let token_program_id = token_definition.account.program_owner;
+    let _definition =
+        crate::validation::canonical_token_definition(&token_definition, token_program_id);
     let seed = ata_core::verify_ata_and_get_seed(
         &ata_account,
         &owner,
@@ -23,6 +25,12 @@ pub fn create_associated_token_account(
 
     // Idempotent: already initialized → no-op
     if ata_account.account != Account::default() {
+        let holding = crate::validation::canonical_ata_holding(&ata_account, token_program_id);
+        assert_eq!(
+            holding.definition_id(),
+            token_definition.account_id,
+            "Existing ATA token definition mismatch"
+        );
         return (
             vec![
                 AccountPostState::new_claimed_if_default(owner.account.clone(), Claim::Authorized),

ata/src/lib.rs

@@ -5,6 +5,7 @@ pub use ata_core as core;
 pub mod burn;
 pub mod create;
 pub mod transfer;
+mod validation;
 
 #[cfg(test)]
 mod tests;