pda & account renaming

Author: grod220

client/src/instruction.rs

@@ -7,11 +7,11 @@ use {
 };
 
 /// Creates an `Initialize` instruction.
-pub fn initialize(programmatic_signer_account: &Address, authority: &Address) -> SolanaInstruction {
+pub fn initialize(signer_nonce_account: &Address, authority: &Address) -> SolanaInstruction {
     SolanaInstruction {
         program_id: spl_ed25519_programmatic_signer_interface::id(),
         accounts: vec![
-            AccountMeta::new(*programmatic_signer_account, false),
+            AccountMeta::new(*signer_nonce_account, 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 programmatic signer account for an authority.
+    /// Initializes a signer nonce 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,70 +18,70 @@ 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" ‖ programmatic_signer_account_address ‖ slot_hashes[0])`.
-    /// 3. Writes `ProgrammaticSignerAccount { nonce, authority }` into the account data.
+    ///    `sha256("spl-ed25519-programmatic-signer::init-v1" ‖ signer_nonce_account_address ‖ slot_hashes[0])`.
+    /// 3. Writes `SignerNonceAccount { nonce, authority }` into the account data.
     ///
     /// Instruction data: instruction discriminator only
     ///
     /// Accounts required:
-    /// - `[writable]` Programmatic signer account
-    /// - `[]` Authority to store in the programmatic signer account
+    /// - `[writable]` Signer nonce account
+    /// - `[]` Authority to store in the signer nonce account
     /// - `[]` `SlotHashes` sysvar
     Initialize,
 
     /// Authorizes and executes a wrapped Solana transaction whose required signers are
-    /// `ProgrammaticSignerPda` accounts.
+    /// `ProgrammaticSigner` accounts.
     ///
     /// Instruction data: instruction discriminator followed by a serialized
     /// `solana_transaction::versioned::VersionedTransaction`.
     /// All message variants supported by `VersionedTransaction` are accepted.
     ///
     /// Wrapped required signers are paired by index:
-    /// - `message.account_keys[i]`: `ProgrammaticSignerPda` promoted during CPI.
+    /// - `message.account_keys[i]`: `ProgrammaticSigner` promoted during CPI.
     /// - `tx.signatures[i]`: wrapped-message signature from the matching authority address.
     ///
     /// On success, the program:
     /// 1. Deserializes the transaction and sanitizes the wrapped message.
-    /// 2. Reads the authority stored in the programmatic signer account.
-    /// 3. Checks the passed programmatic signer account's authority signed 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.
     /// 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`.
     /// 6. Iterates over the outer authority accounts in order. For each `authority_i`, requires
-    ///    `ProgrammaticSignerPda(authority_i) == message.account_keys[i]` and verifies
+    ///    `ProgrammaticSigner(authority_i) == message.account_keys[i]` and verifies
     ///    `tx.signatures[i]` over the wrapped message with `authority_i`.
     /// 7. Executes each `message.instructions` entry by CPI, using `invoke_signed` to promote
-    ///    each authorized signer's corresponding `ProgrammaticSignerPda`.
+    ///    each authorized signer's corresponding `ProgrammaticSigner`.
     /// 8. Derives and stores the next nonce as
-    ///    `sha256("spl-ed25519-programmatic-signer::v1" ‖ programmatic_signer_account ‖ old_nonce ‖ slot_hashes[0] ‖ sha256(signed_message_bytes))`
+    ///    `sha256("spl-ed25519-programmatic-signer::v1" ‖ signer_nonce_account ‖ old_nonce ‖ slot_hashes[0] ‖ sha256(signed_message_bytes))`
     ///
     /// Accounts required:
-    /// - `[writable]` Programmatic signer account whose nonce is consumed and advanced
+    /// - `[writable]` Signer nonce 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 programmatic signer account and refunds its lamports.
+    /// Closes a signer nonce account and refunds its lamports.
     ///
     /// Instruction data: instruction discriminator followed by [`CloseData`].
     ///
     /// Runs only as an inner instruction of a wrapped transaction submitted through `Submit`
-    /// because nothing outside this program can sign for `ProgrammaticSignerPda`.
+    /// because nothing outside this program can sign for `ProgrammaticSigner`.
     ///
     /// Accounts required:
-    /// - `[signer]` `ProgrammaticSignerPda`
-    /// - `[writable]` Programmatic signer account
+    /// - `[signer]` `ProgrammaticSigner`
+    /// - `[writable]` Signer nonce 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 programmatic signer account.
+    /// Address that receives all lamports from the closed signer nonce account.
     pub recipient: Address,
 }
 

interface/src/pda.rs

@@ -1,21 +1,21 @@
 use solana_address::Address;
 
-/// Programmatic signer PDA.
+/// Programmatic signer.
 ///
 /// Program-owned runtime signer for an authority. `Submit` promotes it to `is_signer=true`
 /// via `invoke_signed` wherever a wrapped instruction references it after the corresponding
 /// authority has signed the wrapped message.
 ///
 /// Seeds: `["programmatic-signer", authority, bump]`
-pub struct ProgrammaticSignerPda;
+pub struct ProgrammaticSigner;
 
-impl ProgrammaticSignerPda {
+impl ProgrammaticSigner {
     pub const SEED_PREFIX: &[u8] = b"programmatic-signer";
 
     #[inline(always)]
     pub fn derive_address_and_bump(program_id: &Address, authority: &Address) -> (Address, u8) {
         Address::derive_program_address(&[Self::SEED_PREFIX, authority.as_ref()], program_id)
-            .expect("failed to derive ProgrammaticSignerPda from authority")
+            .expect("failed to derive ProgrammaticSigner from authority")
     }
 
     #[inline(always)]

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 programmatic signer account.
+/// On-chain data for a caller-created signer nonce account.
 ///
-/// One authority can control any number of independent programmatic signer accounts. This is useful for
+/// One authority can control any number of independent signer nonce 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 programmatic signer account.
+/// transactions prepared against another signer nonce account.
 #[derive(Clone, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
-pub struct ProgrammaticSignerAccount {
+pub struct SignerNonceAccount {
     /// 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 ProgrammaticSignerAccount {
     pub authority: Address,
 }
 
-impl ProgrammaticSignerAccount {
+impl SignerNonceAccount {
     /// 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, ProgrammaticSignerAccount};
+    use super::{Address, Hash, SignerNonceAccount};
 
     #[test]
     fn len_matches_wincode_serialized_size() {
-        let account = ProgrammaticSignerAccount {
+        let account = SignerNonceAccount {
             nonce: Hash::new_from_array([1; 32]),
             authority: Address::new_from_array([2; 32]),
         };
 
         assert_eq!(
             wincode::serialized_size(&account).unwrap() as usize,
-            ProgrammaticSignerAccount::LEN
+            SignerNonceAccount::LEN
         );
     }
 }

program/src/initialize.rs

@@ -5,43 +5,37 @@ use {
         sysvars::{Sysvar, rent::Rent, slot_hashes::SlotHashes},
     },
     spl_ed25519_programmatic_signer_interface::state::{
-        INIT_NONCE_DERIVATION_TAG, ProgrammaticSignerAccount,
+        INIT_NONCE_DERIVATION_TAG, SignerNonceAccount,
     },
 };
 
-/// Turns a caller-created, program-owned account into a [`ProgrammaticSignerAccount`]
+/// Turns a caller-created, program-owned account into a [`SignerNonceAccount`]
 /// bound to `authority` with a fresh nonce.
 #[inline(always)]
 pub fn process_initialize(program_id: &Address, accounts: &mut [AccountView]) -> ProgramResult {
-    let [
-        programmatic_signer_account,
-        authority,
-        slot_hashes_account,
-        ..,
-    ] = accounts
-    else {
+    let [signer_nonce_account, authority, slot_hashes_account, ..] = accounts else {
         return Err(ProgramError::NotEnoughAccountKeys);
     };
 
     // Caller must ensure account is pre-created with authority set to the program
-    if !programmatic_signer_account.owned_by(program_id) {
+    if !signer_nonce_account.owned_by(program_id) {
         return Err(ProgramError::IllegalOwner);
     }
 
     // Ensure's the precise length matches the layout
-    if programmatic_signer_account.data_len() != ProgrammaticSignerAccount::LEN {
+    if signer_nonce_account.data_len() != SignerNonceAccount::LEN {
         return Err(ProgramError::InvalidAccountData);
     }
 
     // A fresh account is zero-filled. Any nonzero byte means it is already initialized.
-    let data = programmatic_signer_account.try_borrow()?;
+    let data = signer_nonce_account.try_borrow()?;
     if data.iter().any(|byte| *byte != 0) {
         return Err(ProgramError::AccountAlreadyInitialized);
     }
     drop(data);
 
-    let rent_required = Rent::get()?.try_minimum_balance(ProgrammaticSignerAccount::LEN)?;
-    if programmatic_signer_account.lamports() < rent_required {
+    let rent_required = Rent::get()?.try_minimum_balance(SignerNonceAccount::LEN)?;
+    if signer_nonce_account.lamports() < rent_required {
         return Err(ProgramError::AccountNotRentExempt);
     }
 
@@ -56,18 +50,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
-        programmatic_signer_account.address().as_ref(),
+        signer_nonce_account.address().as_ref(),
         // chain entropy the caller can't choose
         &recent_entry.hash,
     ]);
 
-    let state = ProgrammaticSignerAccount {
+    let state = SignerNonceAccount {
         nonce: initial_nonce,
         authority: Address::from(authority.address()),
     };
 
     // Write data into the account
-    let mut data = programmatic_signer_account.try_borrow_mut()?;
+    let mut data = signer_nonce_account.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::ProgrammaticSignerAccount,
+    spl_ed25519_programmatic_signer_interface::state::SignerNonceAccount,
 };
 
 pub fn init_mollusk() -> Mollusk {
@@ -10,6 +10,6 @@ pub fn init_mollusk() -> Mollusk {
     )
 }
 
-pub fn decode_state(account: &Account) -> ProgrammaticSignerAccount {
+pub fn decode_state(account: &Account) -> SignerNonceAccount {
     wincode::deserialize_exact(&account.data).unwrap()
 }

program/tests/helpers/initialize_builder.rs

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

program/tests/helpers/signer_account_builder.rs

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