chore(feat): requseted changes for seperate current index and ix params functions

Author: Akash Thota

lang/src/signature_verification/ed25519.rs

@@ -3,11 +3,25 @@ use crate::prelude::*;
 use crate::solana_program::instruction::Instruction;
 use solana_sdk_ids::ed25519_program;
 
+/// Verifies an Ed25519 signature instruction assuming the signature, public key,
+/// and message bytes are embedded directly inside the instruction data (Solana's
+/// default encoding). Prefer [`verify_ed25519_ix_with_instruction_index`] when
+/// working with custom instructions that point at external instruction data.
 pub fn verify_ed25519_ix(
     ix: &Instruction,
     pubkey: &[u8; 32],
     msg: &[u8],
     sig: &[u8; 64],
+) -> Result<()> {
+    verify_ed25519_ix_with_instruction_index(ix, u16::MAX, pubkey, msg, sig)
+}
+
+pub fn verify_ed25519_ix_with_instruction_index(
+    ix: &Instruction,
+    instruction_index: u16,
+    pubkey: &[u8; 32],
+    msg: &[u8],
+    sig: &[u8; 64],
 ) -> Result<()> {
     require_keys_eq!(
         ix.program_id,
@@ -31,12 +45,12 @@ pub fn verify_ed25519_ix(
     expected.push(1u8); // num signatures
     expected.push(0u8); // padding
     expected.extend_from_slice(&sig_offset.to_le_bytes());
-    expected.extend_from_slice(&(u16::MAX).to_le_bytes());
+    expected.extend_from_slice(&instruction_index.to_le_bytes());
     expected.extend_from_slice(&pubkey_offset.to_le_bytes());
-    expected.extend_from_slice(&(u16::MAX).to_le_bytes());
+    expected.extend_from_slice(&instruction_index.to_le_bytes());
     expected.extend_from_slice(&msg_offset.to_le_bytes());
     expected.extend_from_slice(&msg_len.to_le_bytes());
-    expected.extend_from_slice(&(u16::MAX).to_le_bytes());
+    expected.extend_from_slice(&instruction_index.to_le_bytes());
 
     expected.extend_from_slice(sig);
     expected.extend_from_slice(pubkey);

lang/src/signature_verification/mod.rs

@@ -1,16 +1,50 @@
 use crate::prelude::*;
 use crate::solana_program::instruction::Instruction;
-use crate::solana_program::sysvar::instructions::load_instruction_at_checked;
+use crate::solana_program::sysvar::instructions::{
+    load_current_index_checked, load_instruction_at_checked,
+};
+use core::convert::TryFrom;
 
 mod ed25519;
 mod secp256k1;
 
-pub use ed25519::verify_ed25519_ix;
-pub use secp256k1::verify_secp256k1_ix;
+pub use ed25519::{verify_ed25519_ix, verify_ed25519_ix_with_instruction_index};
+pub use secp256k1::{verify_secp256k1_ix, verify_secp256k1_ix_with_instruction_index};
 
 /// Load an instruction from the Instructions sysvar at the given index.
 pub fn load_instruction(index: usize, ix_sysvar: &AccountInfo<'_>) -> Result<Instruction> {
     let ix = load_instruction_at_checked(index, ix_sysvar)
         .map_err(|_| error!(error::ErrorCode::ConstraintRaw))?;
     Ok(ix)
 }
+
+/// Loads the instruction currently executing in this transaction and verifies it
+/// as an Ed25519 signature instruction.
+pub fn verify_current_ed25519_instruction(
+    ix_sysvar: &AccountInfo<'_>,
+    pubkey: &[u8; 32],
+    msg: &[u8],
+    sig: &[u8; 64],
+) -> Result<()> {
+    let idx = load_current_index_checked(ix_sysvar)
+        .map_err(|_| error!(error::ErrorCode::ConstraintRaw))?;
+    let ix = load_instruction(idx as usize, ix_sysvar)?;
+    verify_ed25519_ix_with_instruction_index(&ix, idx, pubkey, msg, sig)
+}
+
+/// Loads the instruction currently executing in this transaction and verifies it
+/// as a Secp256k1 signature instruction.
+pub fn verify_current_secp256k1_instruction(
+    ix_sysvar: &AccountInfo<'_>,
+    eth_address: &[u8; 20],
+    msg: &[u8],
+    sig: &[u8; 64],
+    recovery_id: u8,
+) -> Result<()> {
+    let idx_u16 = load_current_index_checked(ix_sysvar)
+        .map_err(|_| error!(error::ErrorCode::ConstraintRaw))?;
+    let idx_u8 =
+        u8::try_from(idx_u16).map_err(|_| error!(error::ErrorCode::InvalidNumericConversion))?;
+    let ix = load_instruction(idx_u16 as usize, ix_sysvar)?;
+    verify_secp256k1_ix_with_instruction_index(&ix, idx_u8, eth_address, msg, sig, recovery_id)
+}

lang/src/signature_verification/secp256k1.rs

@@ -3,12 +3,28 @@ use crate::prelude::*;
 use crate::solana_program::instruction::Instruction;
 use solana_sdk_ids::secp256k1_program;
 
+/// Verifies a Secp256k1 instruction created under the assumption that the
+/// signature, address, and message bytes all live inside the same instruction
+/// (i.e. the signature ix is placed at index `0`). Prefer
+/// [`verify_secp256k1_ix_with_instruction_index`] and pass the actual signature
+/// instruction index instead of relying on this default.
 pub fn verify_secp256k1_ix(
     ix: &Instruction,
     eth_address: &[u8; 20],
     msg: &[u8],
     sig: &[u8; 64],
     recovery_id: u8,
+) -> Result<()> {
+    verify_secp256k1_ix_with_instruction_index(ix, 0, eth_address, msg, sig, recovery_id)
+}
+
+pub fn verify_secp256k1_ix_with_instruction_index(
+    ix: &Instruction,
+    instruction_index: u8,
+    eth_address: &[u8; 20],
+    msg: &[u8],
+    sig: &[u8; 64],
+    recovery_id: u8,
 ) -> Result<()> {
     require_keys_eq!(
         ix.program_id,
@@ -33,12 +49,12 @@ pub fn verify_secp256k1_ix(
 
     expected.push(1u8); // num signatures
     expected.extend_from_slice(&sig_offset.to_le_bytes());
-    expected.push(0u8); // sig ix idx
+    expected.push(instruction_index); // sig ix idx
     expected.extend_from_slice(&eth_offset.to_le_bytes());
-    expected.push(0u8); // eth ix idx
+    expected.push(instruction_index); // eth ix idx
     expected.extend_from_slice(&msg_offset.to_le_bytes());
     expected.extend_from_slice(&msg_len.to_le_bytes());
-    expected.push(0u8); // msg ix idx
+    expected.push(instruction_index); // msg ix idx
 
     expected.extend_from_slice(eth_address);
     expected.extend_from_slice(sig);

tests/signature-verification/programs/signature-verification-test/src/lib.rs

@@ -1,6 +1,7 @@
 use anchor_lang::prelude::*;
 use anchor_lang::signature_verification::{
-    load_instruction, verify_ed25519_ix, verify_secp256k1_ix,
+    load_instruction, verify_ed25519_ix_with_instruction_index,
+    verify_secp256k1_ix_with_instruction_index,
 };
 
 declare_id!("9P8zSbNRQkwDrjCmqsHHcU1GTk5npaKYgKHroAkupbLG");
@@ -15,8 +16,9 @@ pub mod signature_verification_test {
         signature: [u8; 64],
     ) -> Result<()> {
         let ix = load_instruction(0, &ctx.accounts.ix_sysvar)?;
-        verify_ed25519_ix(
+        verify_ed25519_ix_with_instruction_index(
             &ix,
+            u16::MAX,
             &ctx.accounts.signer.key().to_bytes(),
             &message,
             &signature,
@@ -34,7 +36,14 @@ pub mod signature_verification_test {
         eth_address: [u8; 20],
     ) -> Result<()> {
         let ix = load_instruction(0, &ctx.accounts.ix_sysvar)?;
-        verify_secp256k1_ix(&ix, &eth_address, &message, &signature, recovery_id)?;
+        verify_secp256k1_ix_with_instruction_index(
+            &ix,
+            0,
+            &eth_address,
+            &message,
+            &signature,
+            recovery_id,
+        )?;
 
         msg!("Secp256k1 signature verified successfully using custom helper!");