rename to SignerContext

Author: grod220

client/src/instruction.rs

@@ -7,11 +7,11 @@ use {
 };
 
 /// Creates an `Initialize` instruction.
-pub fn initialize(signer_nonce_account: &Address, authority: &Address) -> SolanaInstruction {
+pub fn initialize(signer_context: &Address, authority: &Address) -> SolanaInstruction {
     SolanaInstruction {
         program_id: spl_ed25519_programmatic_signer_interface::id(),
         accounts: vec![
-            AccountMeta::new(*signer_nonce_account, false),
+            AccountMeta::new(*signer_context, false),
             AccountMeta::new_readonly(*authority, false),
             AccountMeta::new_readonly(slot_hashes::id(), false),
         ],

interface/src/instruction.rs

@@ -9,7 +9,7 @@ use {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
 #[wincode(tag_encoding = "u8")]
 pub enum Instruction {
-    /// Initializes a signer nonce account for an authority.
+    /// Initializes a signer context account for an authority.
     ///
     /// The caller must first create and fund the account. Recommended to include
     /// `solana_system_interface::instruction::create_account` and `Initialize` in the same
@@ -18,14 +18,14 @@ pub enum Instruction {
     /// On success, the program:
     /// 1. Verifies the account is uninitialized, rent-exempt, and owned by this program.
     /// 2. Derives the initial `nonce` as
-    ///    `sha256("spl-ed25519-programmatic-signer::init-v1" ‖ signer_nonce_account_address ‖ slot_hashes[0])`.
-    /// 3. Writes `SignerNonceAccount { nonce, authority }` into the account data.
+    ///    `sha256("spl-ed25519-programmatic-signer::init-v1" ‖ signer_context_address ‖ slot_hashes[0])`.
+    /// 3. Writes `SignerContext { nonce, authority }` into the account data.
     ///
     /// Instruction data: instruction discriminator only
     ///
     /// Accounts required:
-    /// - `[writable]` Signer nonce account
-    /// - `[]` Authority to store in the signer nonce account
+    /// - `[writable]` Signer context account
+    /// - `[]` Authority to store in the signer context account
     /// - `[]` `SlotHashes` sysvar
     Initialize,
 
@@ -42,8 +42,8 @@ pub enum Instruction {
     ///
     /// On success, the program:
     /// 1. Deserializes the transaction and sanitizes the wrapped message.
-    /// 2. Reads the authority stored in the signer nonce account.
-    /// 3. Checks the passed signer nonce account's authority signed the wrapped message.
+    /// 2. Reads the authority stored in the signer context account.
+    /// 3. Checks the passed signer context account's authority signed the wrapped message.
     /// 4. Checks the wrapped message's lifetime / recent blockhash field equals the account's
     ///    `nonce`.
     /// 5. Verifies the outer transaction's only top-level instruction is `Submit`.
@@ -53,18 +53,18 @@ pub enum Instruction {
     /// 7. Executes each `message.instructions` entry by CPI, using `invoke_signed` to promote
     ///    each authorized signer's corresponding `ProgrammaticSigner`.
     /// 8. Derives and stores the next nonce as
-    ///    `sha256("spl-ed25519-programmatic-signer::v1" ‖ signer_nonce_account ‖ old_nonce ‖ slot_hashes[0] ‖ sha256(signed_message_bytes))`
+    ///    `sha256("spl-ed25519-programmatic-signer::v1" ‖ signer_context ‖ old_nonce ‖ slot_hashes[0] ‖ sha256(signed_message_bytes))`
     ///
     /// Accounts required:
-    /// - `[writable]` Signer nonce account whose nonce is consumed and advanced
+    /// - `[writable]` Signer context account whose nonce is consumed and advanced
     /// - `[]` `SlotHashes` sysvar
     /// - `[]` `Instructions` sysvar
     /// - Authority addresses, ordered to match the wrapped message's required signers.
     /// - Remaining accounts referenced by the wrapped message, in order. Writable flags
     ///   must match the wrapped message.
     Submit,
 
-    /// Closes a signer nonce account and refunds its lamports.
+    /// Closes a signer context account and refunds its lamports.
     ///
     /// Instruction data: instruction discriminator followed by [`CloseData`].
     ///
@@ -73,15 +73,15 @@ pub enum Instruction {
     ///
     /// Accounts required:
     /// - `[signer]` `ProgrammaticSigner`
-    /// - `[writable]` Signer nonce account
+    /// - `[writable]` Signer context account
     /// - `[writable]` Lamport recipient
     Close,
 }
 
 /// Data for [`Instruction::Close`].
 #[derive(Clone, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
 pub struct CloseData {
-    /// Address that receives all lamports from the closed signer nonce account.
+    /// Address that receives all lamports from the closed signer context account.
     pub recipient: Address,
 }
 

interface/src/state.rs

@@ -12,14 +12,14 @@ use {
 /// Tag for the initial nonce derivation.
 pub const INIT_NONCE_DERIVATION_TAG: &[u8] = b"spl-ed25519-programmatic-signer::init-v1";
 
-/// On-chain data for a caller-created signer nonce account.
+/// On-chain data for a caller-created signer context account.
 ///
-/// One authority can control any number of independent signer nonce accounts. This is useful for
+/// One authority can control any number of independent signer context accounts. This is useful for
 /// when that authority wants to prepare or submit more than one transaction concurrently. Each
 /// account carries its own nonce, so consuming one nonce does not advance or invalidate
-/// transactions prepared against another signer nonce account.
+/// transactions prepared against another signer context account.
 #[derive(Clone, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
-pub struct SignerNonceAccount {
+pub struct SignerContext {
     /// Single-use value that prevents a signed message from being replayed. `Submit` requires this
     /// to match the wrapped message's lifetime field: `lifetime_specifier` for `v1` messages or
     /// `recent_blockhash` for `legacy` and `v0` messages. On success, `Submit` advances it to a
@@ -31,7 +31,7 @@ pub struct SignerNonceAccount {
     pub authority: Address,
 }
 
-impl SignerNonceAccount {
+impl SignerContext {
     /// Serialized account size: a 32-byte nonce followed by a 32-byte authority address.
     pub const LEN: usize = HASH_BYTES + ADDRESS_BYTES;
 }
@@ -71,18 +71,18 @@ unsafe impl<'de, C: Config> SchemaRead<'de, C> for HashBytes {
 
 #[cfg(test)]
 mod tests {
-    use super::{Address, Hash, SignerNonceAccount};
+    use super::{Address, Hash, SignerContext};
 
     #[test]
     fn len_matches_wincode_serialized_size() {
-        let account = SignerNonceAccount {
+        let account = SignerContext {
             nonce: Hash::new_from_array([1; 32]),
             authority: Address::new_from_array([2; 32]),
         };
 
         assert_eq!(
             wincode::serialized_size(&account).unwrap() as usize,
-            SignerNonceAccount::LEN
+            SignerContext::LEN
         );
     }
 }

program/src/initialize.rs

@@ -4,38 +4,36 @@ use {
         error::ProgramError,
         sysvars::{Sysvar, rent::Rent, slot_hashes::SlotHashes},
     },
-    spl_ed25519_programmatic_signer_interface::state::{
-        INIT_NONCE_DERIVATION_TAG, SignerNonceAccount,
-    },
+    spl_ed25519_programmatic_signer_interface::state::{INIT_NONCE_DERIVATION_TAG, SignerContext},
 };
 
-/// Turns a caller-created, program-owned account into a [`SignerNonceAccount`]
+/// Turns a caller-created, program-owned account into a [`SignerContext`]
 /// bound to `authority` with a fresh nonce.
 #[inline(always)]
 pub fn process_initialize(program_id: &Address, accounts: &mut [AccountView]) -> ProgramResult {
-    let [signer_nonce_account, authority, slot_hashes_account, ..] = accounts else {
+    let [signer_context, authority, slot_hashes_account, ..] = accounts else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
     // Caller must ensure account is pre-created with authority set to the program
-    if !signer_nonce_account.owned_by(program_id) {
+    if !signer_context.owned_by(program_id) {
         return Err(ProgramError::IllegalOwner);
     }
 
     // Ensure's the precise length matches the layout
-    if signer_nonce_account.data_len() != SignerNonceAccount::LEN {
+    if signer_context.data_len() != SignerContext::LEN {
         return Err(ProgramError::InvalidAccountData);
     }
 
     // A fresh account is zero-filled. Any nonzero byte means it is already initialized.
-    let data = signer_nonce_account.try_borrow()?;
+    let data = signer_context.try_borrow()?;
     if data.iter().any(|byte| *byte != 0) {
         return Err(ProgramError::AccountAlreadyInitialized);
     }
     drop(data);
 
-    let rent_required = Rent::get()?.try_minimum_balance(SignerNonceAccount::LEN)?;
-    if signer_nonce_account.lamports() < rent_required {
+    let rent_required = Rent::get()?.try_minimum_balance(SignerContext::LEN)?;
+    if signer_context.lamports() < rent_required {
         return Err(ProgramError::AccountNotRentExempt);
     }
 
@@ -50,18 +48,18 @@ pub fn process_initialize(program_id: &Address, accounts: &mut [AccountView]) ->
         // can never equal an advanced one.
         INIT_NONCE_DERIVATION_TAG,
         // so multiple accounts initialized in the same slot don't share the same nonce
-        signer_nonce_account.address().as_ref(),
+        signer_context.address().as_ref(),
         // chain entropy the caller can't choose
         &recent_entry.hash,
     ]);
 
-    let state = SignerNonceAccount {
+    let state = SignerContext {
         nonce: initial_nonce,
         authority: Address::from(authority.address()),
     };
 
     // Write data into the account
-    let mut data = signer_nonce_account.try_borrow_mut()?;
+    let mut data = signer_context.try_borrow_mut()?;
     wincode::serialize_into(&mut *data, &state)
         .map_err(|_| ProgramError::InvalidInstructionData)?;
 

program/tests/helpers/common.rs

@@ -1,6 +1,6 @@
 use {
     mollusk_svm::Mollusk, solana_account::Account,
-    spl_ed25519_programmatic_signer_interface::state::SignerNonceAccount,
+    spl_ed25519_programmatic_signer_interface::state::SignerContext,
 };
 
 pub fn init_mollusk() -> Mollusk {
@@ -10,6 +10,6 @@ pub fn init_mollusk() -> Mollusk {
     )
 }
 
-pub fn decode_state(account: &Account) -> SignerNonceAccount {
+pub fn decode_state(account: &Account) -> SignerContext {
     wincode::deserialize_exact(&account.data).unwrap()
 }

program/tests/helpers/initialize_builder.rs

@@ -1,5 +1,5 @@
 use {
-    crate::helpers::{common::init_mollusk, signer_account_builder::SignerNonceAccountBuilder},
+    crate::helpers::{common::init_mollusk, signer_context_builder::SignerContextBuilder},
     mollusk_svm::{
         Mollusk,
         result::{Check, InstructionResult},
@@ -11,7 +11,7 @@ use {
 
 pub struct InitializeBuilder<'a> {
     mollusk: Mollusk,
-    signer_nonce_account: Option<(Address, Account)>,
+    signer_context: Option<(Address, Account)>,
     authority_address: Option<Address>,
     instruction_data: Option<Vec<u8>>,
     checks: Vec<Check<'a>>,
@@ -21,7 +21,7 @@ impl Default for InitializeBuilder<'_> {
     fn default() -> Self {
         Self {
             mollusk: init_mollusk(),
-            signer_nonce_account: None,
+            signer_context: None,
             authority_address: None,
             instruction_data: None,
             checks: vec![],
@@ -30,8 +30,8 @@ impl Default for InitializeBuilder<'_> {
 }
 
 impl<'a> InitializeBuilder<'a> {
-    pub fn signer_nonce_account(mut self, signer_nonce_account: (Address, Account)) -> Self {
-        self.signer_nonce_account = Some(signer_nonce_account);
+    pub fn signer_context(mut self, signer_context: (Address, Account)) -> Self {
+        self.signer_context = Some(signer_context);
         self
     }
 
@@ -51,21 +51,21 @@ impl<'a> InitializeBuilder<'a> {
     }
 
     pub fn execute(mut self) -> InstructionResult {
-        let signer_nonce_account = self
-            .signer_nonce_account
-            .unwrap_or_else(|| SignerNonceAccountBuilder::default().build());
+        let signer_context = self
+            .signer_context
+            .unwrap_or_else(|| SignerContextBuilder::default().build());
         let authority_address = self
             .authority_address
             .unwrap_or_else(|| Address::from([2; 32]));
         let slot_hashes = self.mollusk.sysvars.keyed_account_for_slot_hashes_sysvar();
 
-        let mut instruction = initialize(&signer_nonce_account.0, &authority_address);
+        let mut instruction = initialize(&signer_context.0, &authority_address);
         if let Some(instruction_data) = self.instruction_data {
             instruction.data = instruction_data;
         }
 
         let accounts = vec![
-            signer_nonce_account,
+            signer_context,
             (authority_address, Account::default()),
             slot_hashes,
         ];

program/tests/helpers/mod.rs

@@ -1,3 +1,3 @@
 pub mod common;
 pub mod initialize_builder;
-pub mod signer_account_builder;
+pub mod signer_context_builder;

…/tests/helpers/signer_account_builder.rs …/tests/helpers/signer_context_builder.rsprogram/tests/helpers/signer_account_builder.rs renamed to program/tests/helpers/signer_context_builder.rs program/tests/helpers/signer_account_builder.rs renamed to program/tests/helpers/signer_context_builder.rs

@@ -1,16 +1,16 @@
 use {
     solana_account::Account, solana_address::Address, solana_rent::Rent,
-    spl_ed25519_programmatic_signer_interface::state::SignerNonceAccount,
+    spl_ed25519_programmatic_signer_interface::state::SignerContext,
 };
 
-pub struct SignerNonceAccountBuilder {
+pub struct SignerContextBuilder {
     key: Address,
     owner: Address,
     lamports: Option<u64>,
     data: Option<Vec<u8>>,
 }
 
-impl Default for SignerNonceAccountBuilder {
+impl Default for SignerContextBuilder {
     fn default() -> Self {
         Self {
             key: Address::from([1; 32]),
@@ -21,7 +21,7 @@ impl Default for SignerNonceAccountBuilder {
     }
 }
 
-impl SignerNonceAccountBuilder {
+impl SignerContextBuilder {
     pub fn new() -> Self {
         Self::default()
     }
@@ -50,7 +50,7 @@ impl SignerNonceAccountBuilder {
         let data = self
             .data
             // Default to program-owned, zero-filled account (waiting to be initialized)
-            .unwrap_or_else(|| vec![0; SignerNonceAccount::LEN]);
+            .unwrap_or_else(|| vec![0; SignerContext::LEN]);
         let lamports = self
             .lamports
             .unwrap_or_else(|| Rent::default().minimum_balance(data.len()));