feat(processor): port wallet/authority/execute/session processors from upstream

Byte-identical with lazorkit-protocol/program/src/processor/{wallet/create,
authority/manage, authority/transfer_ownership, execute/deferred,
session/revoke}.rs.

Brings the on-chain authority data layout into alignment with upstream:
  Secp256r1 authority = header(48) + cred_hash(32) + pubkey(33) + rpIdHash(32) = 145B
Previously program-v2 stored variable-length raw rpId; the new layout stores
a precomputed SHA256 digest at offset 113. Saves one sol_sha256 syscall per
Execute. Critical for slot-share: existing wallets created on lazorkit-protocol
must remain readable after binary swap.

File names stay flat (program-v2 keeps `processor/create_wallet.rs` rather
than upstream's `processor/wallet/create.rs`); content identical.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: onspeedhp

program/src/processor/create_wallet.rs

@@ -79,10 +79,13 @@ pub fn process(
 
     let (id_seed, full_auth_data) = match args.authority_type {
         0 => {
-            if rest.len() != 32 {
+            // Use minimum-length check (consistent with AddAuthority / TransferOwnership).
+            // Exact-length check would reject clients that append trailing context bytes.
+            if rest.len() < 32 {
                 return Err(ProgramError::InvalidInstructionData);
             }
-            (rest, rest)
+            let (pubkey, _) = rest.split_at(32);
+            (pubkey, pubkey)
         },
         1 => {
             // [credential_id_hash(32)] [pubkey(33)] [rpIdLen(1)] [rpId(N)]
@@ -91,6 +94,12 @@ pub fn process(
             }
             let (credential_id_hash, rest_after_cred) = rest.split_at(32);
             let rp_id_len = rest_after_cred[33] as usize;
+            // Enforce a sane upper bound: max valid domain name is 253 chars.
+            // Without this an attacker-controlled payer could create a 369-byte
+            // authority account with 255 bytes of arbitrary rpId data.
+            if rp_id_len == 0 || rp_id_len > 253 {
+                return Err(ProgramError::InvalidInstructionData);
+            }
             let total_auth_data = 32 + 33 + 1 + rp_id_len;
             if rest.len() < total_auth_data {
                 return Err(ProgramError::InvalidInstructionData);
@@ -188,11 +197,18 @@ pub fn process(
     }
 
     // --- 2. Initialize Authority Account ---
-    // Authority accounts have a variable size depending on the authority type (e.g., Secp256r1 keys are larger).
+    // Fixed sizes per auth type:
+    //   Ed25519   = header(48) + pubkey(32) = 80 bytes
+    //   Secp256r1 = header(48) + cred_hash(32) + pubkey(33) + rpIdHash(32) = 145 bytes
+    //
+    // For Secp256r1 we hash rpId once at creation and store the digest, so
+    // every subsequent Execute saves one sol_sha256 syscall.
     let header_size = std::mem::size_of::<AuthorityAccountHeader>();
-    let variable_size = full_auth_data.len();
-
-    let auth_space = header_size + variable_size;
+    let auth_space = match args.authority_type {
+        0 => header_size + 32,              // Ed25519
+        1 => header_size + 32 + 33 + 32,    // Secp256r1 fixed
+        _ => return Err(AuthError::InvalidAuthenticationKind.into()),
+    };
     let auth_rent = rent.minimum_balance(auth_space);
 
     // Use secure transfer-allocate-assign pattern to prevent DoS (Issue #4)
@@ -228,18 +244,50 @@ pub fn process(
         wallet: *wallet_pda.key(),
     };
 
-    // safe write
+    // safe write of header
     let header_bytes = unsafe {
         std::slice::from_raw_parts(
             &header as *const AuthorityAccountHeader as *const u8,
-            std::mem::size_of::<AuthorityAccountHeader>(),
+            header_size,
         )
     };
-    auth_account_data[0..std::mem::size_of::<AuthorityAccountHeader>()]
-        .copy_from_slice(header_bytes);
+    auth_account_data[0..header_size].copy_from_slice(header_bytes);
 
-    let variable_target = &mut auth_account_data[header_size..];
-    variable_target.copy_from_slice(full_auth_data);
+    // Write variable data
+    match args.authority_type {
+        0 => {
+            // Ed25519: pubkey(32) — full_auth_data is exactly 32 bytes
+            auth_account_data[header_size..header_size + 32]
+                .copy_from_slice(&full_auth_data[..32]);
+        }
+        1 => {
+            // Secp256r1: cred_hash(32) ∥ pubkey(33) ∥ rpIdHash(32).
+            // full_auth_data layout as parsed above:
+            //   [cred_hash(32)] [pubkey(33)] [rpIdLen(1)] [rpId(N)]
+            auth_account_data[header_size..header_size + 32]
+                .copy_from_slice(&full_auth_data[..32]);
+            auth_account_data[header_size + 32..header_size + 32 + 33]
+                .copy_from_slice(&full_auth_data[32..32 + 33]);
+            // Compute rpIdHash from rpId
+            let rp_id_len = full_auth_data[32 + 33] as usize;
+            let rp_id = &full_auth_data[32 + 33 + 1..32 + 33 + 1 + rp_id_len];
+            let rp_id_hash_offset = header_size + 32 + 33;
+            #[cfg(target_os = "solana")]
+            unsafe {
+                let _ = pinocchio::syscalls::sol_sha256(
+                    [rp_id].as_ptr() as *const u8,
+                    1,
+                    auth_account_data[rp_id_hash_offset..rp_id_hash_offset + 32].as_mut_ptr(),
+                );
+            }
+            #[cfg(not(target_os = "solana"))]
+            {
+                let _ = rp_id;
+                auth_account_data[rp_id_hash_offset..rp_id_hash_offset + 32].fill(0);
+            }
+        }
+        _ => unreachable!(),
+    }
 
     Ok(())
 }

program/src/processor/execute_deferred.rs

@@ -1,5 +1,5 @@
 use crate::{
-    compact::parse_compact_instructions,
+    compact::{parse_compact_instructions_ref_with_len, CompactInstructionRef},
     error::AuthError,
     state::{deferred::DeferredExecAccount, AccountDiscriminator},
 };
@@ -99,14 +99,14 @@ pub fn process(
         return Err(AuthError::DeferredAuthorizationExpired.into());
     }
 
-    // Parse compact instructions
-    let compact_instructions = parse_compact_instructions(instruction_data)?;
+    // Parse compact instructions and track consumed length. We hash the
+    // raw instruction_data[..consumed] directly — the parse/encode format
+    // is byte-identical, so there's no need to re-serialize.
+    let (compact_instructions, compact_len) =
+        parse_compact_instructions_ref_with_len(instruction_data)?;
 
-    // Serialize compact instructions to compute hash
-    let compact_bytes = crate::compact::serialize_compact_instructions(&compact_instructions);
-
-    // Verify instructions hash
-    let instructions_hash = compute_sha256(&compact_bytes);
+    // Verify instructions hash against the exact bytes we parsed from
+    let instructions_hash = compute_sha256(&instruction_data[..compact_len]);
     if instructions_hash != deferred.instructions_hash {
         return Err(AuthError::DeferredHashMismatch.into());
     }
@@ -140,46 +140,47 @@ pub fn process(
     let close_data = unsafe { deferred_pda.borrow_mut_data_unchecked() };
     close_data.fill(0);
 
+    // Reuse Vecs across inner CPI iterations — allocated once, cleared +
+    // repushed each iteration. Same optimisation as execute::immediate.
+    const MAX_INNER_ACCOUNTS: usize = 32;
+    let mut account_metas: Vec<AccountMeta> = Vec::with_capacity(MAX_INNER_ACCOUNTS);
+    let mut cpi_accounts: Vec<Account> = Vec::with_capacity(MAX_INNER_ACCOUNTS);
+
+    let vault_bump_arr = [vault_bump];
+    let seeds = [
+        Seed::from(b"vault"),
+        Seed::from(wallet_pda.key().as_ref()),
+        Seed::from(&vault_bump_arr),
+    ];
+
     // Execute each compact instruction via CPI with vault PDA signing
     for compact_ix in &compact_instructions {
         let decompressed = compact_ix.decompress(accounts)?;
 
-        // Build AccountMeta array
-        let account_metas: Vec<AccountMeta> = decompressed
-            .accounts
-            .iter()
-            .map(|acc| AccountMeta {
-                pubkey: acc.key(),
-                is_signer: acc.is_signer() || acc.key() == vault_pda.key(),
-                is_writable: acc.is_writable(),
-            })
-            .collect();
-
         // Prevent self-reentrancy
         if decompressed.program_id.as_ref() == program_id.as_ref() {
             return Err(AuthError::SelfReentrancyNotAllowed.into());
         }
 
+        account_metas.clear();
+        cpi_accounts.clear();
+        for &acc in &decompressed.accounts {
+            account_metas.push(AccountMeta {
+                pubkey: acc.key(),
+                is_signer: acc.is_signer() || acc.key() == vault_pda.key(),
+                is_writable: acc.is_writable(),
+            });
+            cpi_accounts.push(Account::from(acc));
+        }
+
         let ix = Instruction {
             program_id: decompressed.program_id,
             accounts: &account_metas,
-            data: &decompressed.data,
+            data: decompressed.data,
         };
 
-        let vault_bump_arr = [vault_bump];
-        let seeds = [
-            Seed::from(b"vault"),
-            Seed::from(wallet_pda.key().as_ref()),
-            Seed::from(&vault_bump_arr),
-        ];
         let signer: Signer = (&seeds).into();
 
-        let cpi_accounts: Vec<Account> = decompressed
-            .accounts
-            .iter()
-            .map(|acc| Account::from(*acc))
-            .collect();
-
         unsafe {
             invoke_signed_unchecked(&ix, &cpi_accounts, &[signer]);
         }
@@ -209,26 +210,26 @@ fn compute_sha256(data: &[u8]) -> [u8; 32] {
 }
 
 /// Compute SHA256 hash of all account pubkeys referenced by compact instructions.
-/// Same logic as execute.rs::compute_accounts_hash.
+/// Matches execute::immediate::compute_accounts_hash.
 fn compute_accounts_hash(
     accounts: &[AccountInfo],
-    compact_instructions: &[crate::compact::CompactInstruction],
+    compact_instructions: &[CompactInstructionRef<'_>],
 ) -> Result<[u8; 32], ProgramError> {
-    let mut pubkeys_data = Vec::new();
+    let mut refs: Vec<&[u8]> = Vec::with_capacity(compact_instructions.len() * 4);
 
     for ix in compact_instructions {
         let program_idx = ix.program_id_index as usize;
         if program_idx >= accounts.len() {
             return Err(ProgramError::InvalidInstructionData);
         }
-        pubkeys_data.extend_from_slice(accounts[program_idx].key().as_ref());
+        refs.push(accounts[program_idx].key().as_ref());
 
-        for &acc_idx in &ix.accounts {
+        for &acc_idx in ix.accounts {
             let idx = acc_idx as usize;
             if idx >= accounts.len() {
                 return Err(ProgramError::InvalidInstructionData);
             }
-            pubkeys_data.extend_from_slice(accounts[idx].key().as_ref());
+            refs.push(accounts[idx].key().as_ref());
         }
     }
 
@@ -237,15 +238,15 @@ fn compute_accounts_hash(
     #[cfg(target_os = "solana")]
     unsafe {
         pinocchio::syscalls::sol_sha256(
-            [pubkeys_data.as_slice()].as_ptr() as *const u8,
-            1,
+            refs.as_ptr() as *const u8,
+            refs.len() as u64,
             hash.as_mut_ptr(),
         );
     }
     #[cfg(not(target_os = "solana"))]
     {
         hash = [0xAA; 32];
-        let _ = pubkeys_data;
+        let _ = refs;
     }
 
     Ok(hash)

program/src/processor/manage_authority.rs

@@ -91,6 +91,9 @@ pub fn process_add_authority(
             }
             let (credential_id_hash, rest_after_cred) = rest.split_at(32);
             let rp_id_len = rest_after_cred[33] as usize;
+            if rp_id_len == 0 || rp_id_len > 253 {
+                return Err(ProgramError::InvalidInstructionData);
+            }
             let total_auth_data = 32 + 33 + 1 + rp_id_len;
             if rest.len() < total_auth_data {
                 return Err(ProgramError::InvalidInstructionData);
@@ -198,6 +201,12 @@ pub fn process_add_authority(
     }
 
     // Authorization
+    // Validate new_role is a known value (0=Owner, 1=Admin, 2=Spender).
+    // Without this check an Owner could create a role-255 authority that can
+    // execute but cannot be revoked by any Admin.
+    if args.new_role > 2 {
+        return Err(AuthError::PermissionDenied.into());
+    }
     if admin_header.role != 0 && (admin_header.role != 1 || args.new_role != 2) {
         return Err(AuthError::PermissionDenied.into());
     }
@@ -212,9 +221,13 @@ pub fn process_add_authority(
     }
     check_zero_data(new_auth_pda, ProgramError::AccountAlreadyInitialized)?;
 
+    // Fixed sizes per auth type (see wallet/create.rs for layout).
     let header_size = std::mem::size_of::<AuthorityAccountHeader>();
-    let variable_size = full_auth_data.len();
-    let space = header_size + variable_size;
+    let space = match args.authority_type {
+        0 => header_size + 32,                // Ed25519: pubkey
+        1 => header_size + 32 + 33 + 32,      // Secp256r1: cred ∥ pubkey ∥ rpIdHash
+        _ => return Err(AuthError::InvalidAuthenticationKind.into()),
+    };
     let rent_lamports = rent.minimum_balance(space);
 
     // Use secure transfer-allocate-assign pattern to prevent DoS (Issue #4)
@@ -252,8 +265,35 @@ pub fn process_add_authority(
         *(data.as_mut_ptr() as *mut AuthorityAccountHeader) = header;
     }
 
-    let variable_target = &mut data[header_size..];
-    variable_target.copy_from_slice(full_auth_data);
+    // Write variable data. For Secp256r1 hash rpId once here so every Execute
+    // saves a sol_sha256 syscall.
+    match args.authority_type {
+        0 => {
+            data[header_size..header_size + 32].copy_from_slice(&full_auth_data[..32]);
+        }
+        1 => {
+            data[header_size..header_size + 32].copy_from_slice(&full_auth_data[..32]);
+            data[header_size + 32..header_size + 32 + 33]
+                .copy_from_slice(&full_auth_data[32..32 + 33]);
+            let rp_id_len = full_auth_data[32 + 33] as usize;
+            let rp_id = &full_auth_data[32 + 33 + 1..32 + 33 + 1 + rp_id_len];
+            let rp_id_hash_offset = header_size + 32 + 33;
+            #[cfg(target_os = "solana")]
+            unsafe {
+                let _ = pinocchio::syscalls::sol_sha256(
+                    [rp_id].as_ptr() as *const u8,
+                    1,
+                    data[rp_id_hash_offset..rp_id_hash_offset + 32].as_mut_ptr(),
+                );
+            }
+            #[cfg(not(target_os = "solana"))]
+            {
+                let _ = rp_id;
+                data[rp_id_hash_offset..rp_id_hash_offset + 32].fill(0);
+            }
+        }
+        _ => unreachable!(),
+    }
 
     Ok(())
 }
@@ -398,6 +438,12 @@ pub fn process_remove_authority(
         }
     }
 
+    // Guard: if target == refund_dest the double-write would burn lamports and
+    // trigger a Solana lamport conservation error, aborting after doing work.
+    if target_auth_pda.key() == refund_dest.key() {
+        return Err(ProgramError::InvalidAccountData);
+    }
+
     let target_lamports = unsafe { *target_auth_pda.borrow_mut_lamports_unchecked() };
     let refund_lamports = unsafe { *refund_dest.borrow_mut_lamports_unchecked() };
     unsafe {

program/src/processor/revoke_session.rs

@@ -136,6 +136,11 @@ pub fn process(
         return Err(ProgramError::InvalidAccountData);
     }
 
+    // Guard: session_pda == refund_dest would burn lamports.
+    if session_pda.key() == refund_dest.key() {
+        return Err(ProgramError::InvalidAccountData);
+    }
+
     // Close the session account — zero data and drain lamports
     session_data.fill(0);