Add initial signed-memo program (#1135)

* Initial s-memo

* Populate readme

* Add signed-memo to spl docs

* Log less, fail faster

* Replace and bump memo

* Update memo id

* Add memo prefix and len

* Add test that demonstrates compute bounds

* Add logging and compute to memo docs

Author: CriesofCarrots

program/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spl-memo"
-version = "2.0.1"
+version = "3.0.0"
 description = "Solana Program Library Memo"
 authors = ["Solana Maintainers <[email protected]>"]
 repository = "https://github.com/solana-labs/solana-program-library"
@@ -9,10 +9,16 @@ edition = "2018"
 
 [features]
 no-entrypoint = []
+test-bpf = []
 
 [dependencies]
 solana-program = "1.5.1"
 
+[dev-dependencies]
+solana-program-test = "1.5.1"
+solana-sdk = "1.5.1"
+tokio = { version = "0.3", features = ["macros"]}
+
 [lib]
 crate-type = ["cdylib", "lib"]
 

program/src/entrypoint.rs

@@ -1,43 +1,16 @@
 //! Program entrypoint
 
+#![cfg(not(feature = "no-entrypoint"))]
+
 use solana_program::{
-    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, program_error::ProgramError,
-    pubkey::Pubkey,
+    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, pubkey::Pubkey,
 };
-use std::str::from_utf8;
 
 entrypoint!(process_instruction);
 fn process_instruction(
-    _program_id: &Pubkey,
-    _accounts: &[AccountInfo],
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> ProgramResult {
-    from_utf8(instruction_data).map_err(|_| ProgramError::InvalidInstructionData)?;
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_program::{program_error::ProgramError, pubkey::Pubkey};
-
-    #[test]
-    fn test_utf8_memo() {
-        let program_id = Pubkey::new(&[0; 32]);
-
-        let string = b"letters and such";
-        assert_eq!(Ok(()), process_instruction(&program_id, &[], string));
-
-        let emoji = "🐆".as_bytes();
-        let bytes = [0xF0, 0x9F, 0x90, 0x86];
-        assert_eq!(emoji, bytes);
-        assert_eq!(Ok(()), process_instruction(&program_id, &[], &emoji));
-
-        let mut bad_utf8 = bytes;
-        bad_utf8[3] = 0xFF; // Invalid UTF-8 byte
-        assert_eq!(
-            Err(ProgramError::InvalidInstructionData),
-            process_instruction(&program_id, &[], &bad_utf8)
-        );
-    }
+    crate::processor::process_instruction(program_id, accounts, instruction_data)
 }

program/src/lib.rs

@@ -1,11 +1,34 @@
 #![deny(missing_docs)]
 
-//! A simple program that accepts a string of encoded characters and verifies that it parses. Currently handles UTF-8.
+//! A program that accepts a string of encoded characters and verifies that it parses,
+//! while verifying and logging signers. Currently handles UTF-8 characters.
 
-#[cfg(not(feature = "no-entrypoint"))]
 mod entrypoint;
+pub mod processor;
 
 // Export current sdk types for downstream users building with a different sdk version
 pub use solana_program;
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
 
-solana_program::declare_id!("Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo");
+solana_program::declare_id!("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+
+/// Build a memo instruction, possibly signed
+///
+/// Accounts expected by this instruction:
+///
+///   0. ..0+N. `[signer]` Expected signers; if zero provided, instruction will be processed as a
+///     normal, unsigned spl-memo
+///
+pub fn build_memo(memo: &[u8], signer_pubkeys: &[&Pubkey]) -> Instruction {
+    Instruction {
+        program_id: id(),
+        accounts: signer_pubkeys
+            .iter()
+            .map(|&pubkey| AccountMeta::new_readonly(*pubkey, true))
+            .collect(),
+        data: memo.to_vec(),
+    }
+}

program/src/processor.rs

@@ -0,0 +1,109 @@
+//! Program state processor
+
+use solana_program::{
+    account_info::AccountInfo, entrypoint::ProgramResult, msg, program_error::ProgramError,
+    pubkey::Pubkey,
+};
+use std::str::from_utf8;
+
+/// Instruction processor
+pub fn process_instruction(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    input: &[u8],
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+    let mut missing_required_signature = false;
+    for account_info in account_info_iter {
+        if let Some(address) = account_info.signer_key() {
+            msg!("Signed by {:?}", address);
+        } else {
+            missing_required_signature = true;
+        }
+    }
+    if missing_required_signature {
+        return Err(ProgramError::MissingRequiredSignature);
+    }
+
+    let memo = from_utf8(input).map_err(|err| {
+        msg!("Invalid UTF-8, from byte {}", err.valid_up_to());
+        ProgramError::InvalidInstructionData
+    })?;
+    msg!("Memo (len {}): {:?}", memo.len(), memo);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_program::{
+        account_info::IntoAccountInfo, program_error::ProgramError, pubkey::Pubkey,
+    };
+    use solana_sdk::account::Account;
+
+    #[test]
+    fn test_utf8_memo() {
+        let program_id = Pubkey::new(&[0; 32]);
+
+        let string = b"letters and such";
+        assert_eq!(Ok(()), process_instruction(&program_id, &[], string));
+
+        let emoji = "🐆".as_bytes();
+        let bytes = [0xF0, 0x9F, 0x90, 0x86];
+        assert_eq!(emoji, bytes);
+        assert_eq!(Ok(()), process_instruction(&program_id, &[], &emoji));
+
+        let mut bad_utf8 = bytes;
+        bad_utf8[3] = 0xFF; // Invalid UTF-8 byte
+        assert_eq!(
+            Err(ProgramError::InvalidInstructionData),
+            process_instruction(&program_id, &[], &bad_utf8)
+        );
+    }
+
+    #[test]
+    fn test_signers() {
+        let program_id = Pubkey::new(&[0; 32]);
+        let memo = "🐆".as_bytes();
+
+        let pubkey0 = Pubkey::new_unique();
+        let pubkey1 = Pubkey::new_unique();
+        let pubkey2 = Pubkey::new_unique();
+        let mut account0 = Account::default();
+        let mut account1 = Account::default();
+        let mut account2 = Account::default();
+
+        let signed_account_infos = vec![
+            (&pubkey0, true, &mut account0).into_account_info(),
+            (&pubkey1, true, &mut account1).into_account_info(),
+            (&pubkey2, true, &mut account2).into_account_info(),
+        ];
+        assert_eq!(
+            Ok(()),
+            process_instruction(&program_id, &signed_account_infos, memo)
+        );
+
+        assert_eq!(Ok(()), process_instruction(&program_id, &[], memo));
+
+        let unsigned_account_infos = vec![
+            (&pubkey0, false, &mut account0).into_account_info(),
+            (&pubkey1, false, &mut account1).into_account_info(),
+            (&pubkey2, false, &mut account2).into_account_info(),
+        ];
+        assert_eq!(
+            Err(ProgramError::MissingRequiredSignature),
+            process_instruction(&program_id, &unsigned_account_infos, memo)
+        );
+
+        let partially_signed_account_infos = vec![
+            (&pubkey0, true, &mut account0).into_account_info(),
+            (&pubkey1, false, &mut account1).into_account_info(),
+            (&pubkey2, true, &mut account2).into_account_info(),
+        ];
+        assert_eq!(
+            Err(ProgramError::MissingRequiredSignature),
+            process_instruction(&program_id, &partially_signed_account_infos, memo)
+        );
+    }
+}