Merge pull request #6 from solana-program/entity-name-updates

Entity name update follow ups

Author: grod220

client/src/instruction.rs

@@ -1,20 +1,20 @@
 use {
     alloc::vec,
     solana_address::Address,
-    solana_instruction::{AccountMeta, Instruction},
+    solana_instruction::{AccountMeta, Instruction as SolanaInstruction},
     solana_sdk_ids::sysvar::slot_hashes,
-    spl_ed25519_programmatic_signer_interface::instruction::ProgrammaticSignerInstruction,
+    spl_ed25519_programmatic_signer_interface::instruction::Instruction,
 };
 
 /// Creates an `Initialize` instruction.
-pub fn initialize(programmatic_signer_account: &Address, authority: &Address) -> Instruction {
-    Instruction {
+pub fn initialize(signer_context: &Address, authority: &Address) -> SolanaInstruction {
+    SolanaInstruction {
         program_id: spl_ed25519_programmatic_signer_interface::id(),
         accounts: vec![
-            AccountMeta::new(*programmatic_signer_account, false),
+            AccountMeta::new(*signer_context, false),
             AccountMeta::new_readonly(*authority, false),
             AccountMeta::new_readonly(slot_hashes::id(), false),
         ],
-        data: vec![ProgrammaticSignerInstruction::Initialize as u8],
+        data: vec![Instruction::Initialize as u8],
     }
 }

interface/src/instruction.rs

@@ -8,8 +8,8 @@ use {
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
 #[wincode(tag_encoding = "u8")]
-pub enum ProgrammaticSignerInstruction {
-    /// Initializes a programmatic signer account for an authority.
+pub enum Instruction {
+    /// 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,74 +18,74 @@ pub enum ProgrammaticSignerInstruction {
     /// 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_context_address ‖ slot_hashes[0])`.
+    /// 3. Writes `SignerContext { 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 context account
+    /// - `[]` Authority to store in the signer context 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 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`.
     /// 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_context ‖ old_nonce ‖ slot_hashes[0] ‖ sha256(signed_message_bytes))`
     ///
     /// Accounts required:
-    /// - `[writable]` Programmatic signer 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 programmatic signer account and refunds its lamports.
+    /// Closes a signer context 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 context account
     /// - `[writable]` Lamport recipient
     Close,
 }
 
-/// Data for [`ProgrammaticSignerInstruction::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 context account.
     pub recipient: Address,
 }
 
-impl ProgrammaticSignerInstruction {
+impl Instruction {
     #[inline(always)]
     pub fn try_from_bytes(instruction_data: &[u8]) -> Result<Self, ProgramError> {
         wincode::deserialize_exact(instruction_data)
@@ -95,30 +95,24 @@ impl ProgrammaticSignerInstruction {
 
 #[cfg(test)]
 mod tests {
-    use super::ProgrammaticSignerInstruction;
+    use super::Instruction;
 
-    fn instruction_bytes(instruction: ProgrammaticSignerInstruction) -> [u8; 1] {
+    fn instruction_bytes(instruction: Instruction) -> [u8; 1] {
         let mut bytes = [0];
         wincode::serialize_into(bytes.as_mut_slice(), &instruction).unwrap();
         bytes
     }
 
     #[test]
     fn instruction_tags_match_wire_format() {
-        assert_eq!(
-            instruction_bytes(ProgrammaticSignerInstruction::Initialize),
-            [0]
-        );
-        assert_eq!(
-            instruction_bytes(ProgrammaticSignerInstruction::Submit),
-            [1]
-        );
-        assert_eq!(instruction_bytes(ProgrammaticSignerInstruction::Close), [2]);
+        assert_eq!(instruction_bytes(Instruction::Initialize), [0]);
+        assert_eq!(instruction_bytes(Instruction::Submit), [1]);
+        assert_eq!(instruction_bytes(Instruction::Close), [2]);
     }
 
     #[test]
     fn try_from_bytes_rejects_unknown() {
-        assert!(ProgrammaticSignerInstruction::try_from_bytes(&[4]).is_err());
-        assert!(ProgrammaticSignerInstruction::try_from_bytes(&[255]).is_err());
+        assert!(Instruction::try_from_bytes(&[4]).is_err());
+        assert!(Instruction::try_from_bytes(&[255]).is_err());
     }
 }

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 context 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 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 programmatic signer account.
+/// transactions prepared against another signer context account.
 #[derive(Clone, Debug, PartialEq, Eq, SchemaRead, SchemaWrite)]
-pub struct ProgrammaticSignerAccount {
+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 ProgrammaticSignerAccount {
     pub authority: Address,
 }
 
-impl ProgrammaticSignerAccount {
+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, ProgrammaticSignerAccount};
+    use super::{Address, Hash, SignerContext};
 
     #[test]
     fn len_matches_wincode_serialized_size() {
-        let account = ProgrammaticSignerAccount {
+        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,
-            ProgrammaticSignerAccount::LEN
+            SignerContext::LEN
         );
     }
 }

program/src/initialize.rs

@@ -4,44 +4,36 @@ use {
         error::ProgramError,
         sysvars::{Sysvar, rent::Rent, slot_hashes::SlotHashes},
     },
-    spl_ed25519_programmatic_signer_interface::state::{
-        INIT_NONCE_DERIVATION_TAG, ProgrammaticSignerAccount,
-    },
+    spl_ed25519_programmatic_signer_interface::state::{INIT_NONCE_DERIVATION_TAG, SignerContext},
 };
 
-/// Turns a caller-created, program-owned account into a [`ProgrammaticSignerAccount`]
+/// 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 [
-        programmatic_signer_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 !programmatic_signer_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 programmatic_signer_account.data_len() != ProgrammaticSignerAccount::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 = programmatic_signer_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(ProgrammaticSignerAccount::LEN)?;
-    if programmatic_signer_account.lamports() < rent_required {
+    let rent_required = Rent::get()?.try_minimum_balance(SignerContext::LEN)?;
+    if signer_context.lamports() < rent_required {
         return Err(ProgramError::AccountNotRentExempt);
     }
 
@@ -56,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
-        programmatic_signer_account.address().as_ref(),
+        signer_context.address().as_ref(),
         // chain entropy the caller can't choose
         &recent_entry.hash,
     ]);
 
-    let state = ProgrammaticSignerAccount {
+    let state = SignerContext {
         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_context.try_borrow_mut()?;
     wincode::serialize_into(&mut *data, &state)
         .map_err(|_| ProgramError::InvalidInstructionData)?;
 

program/src/processor.rs

@@ -1,7 +1,7 @@
 use {
     crate::initialize::process_initialize,
     pinocchio::{AccountView, Address, ProgramResult},
-    spl_ed25519_programmatic_signer_interface::instruction::ProgrammaticSignerInstruction,
+    spl_ed25519_programmatic_signer_interface::instruction::Instruction,
 };
 
 #[inline(always)]
@@ -10,10 +10,8 @@ pub fn process_instruction(
     accounts: &mut [AccountView],
     instruction_data: &[u8],
 ) -> ProgramResult {
-    match ProgrammaticSignerInstruction::try_from_bytes(instruction_data)? {
-        ProgrammaticSignerInstruction::Initialize => process_initialize(program_id, accounts),
-        ProgrammaticSignerInstruction::Submit | ProgrammaticSignerInstruction::Close => {
-            unimplemented!()
-        }
+    match Instruction::try_from_bytes(instruction_data)? {
+        Instruction::Initialize => process_initialize(program_id, accounts),
+        Instruction::Submit | Instruction::Close => unimplemented!(),
     }
 }

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::SignerContext,
 };
 
 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) -> SignerContext {
     wincode::deserialize_exact(&account.data).unwrap()
 }