program: Port over history from SPL

program/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "spl-memo"
+version = "6.0.0"
+description = "Solana Program Library Memo"
+authors = ["Solana Labs Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2021"
+
+[features]
+no-entrypoint = []
+test-sbf = []
+
+[dependencies]
+solana-account-info = "2.1.0"
+solana-instruction = "2.1.0"
+solana-msg = "2.1.0"
+solana-program-entrypoint = "2.1.0"
+solana-program-error = "2.1.0"
+solana-pubkey = "2.1.0"
+
+[dev-dependencies]
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

program/src/entrypoint.rs

@@ -0,0 +1,17 @@
+//! Program entrypoint
+
+#![cfg(not(feature = "no-entrypoint"))]
+
+use {
+    solana_account_info::AccountInfo, solana_program_entrypoint::ProgramResult,
+    solana_pubkey::Pubkey,
+};
+
+solana_program_entrypoint::entrypoint!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    crate::processor::process_instruction(program_id, accounts, instruction_data)
+}

program/src/lib.rs

@@ -0,0 +1,58 @@
+#![deny(missing_docs)]
+
+//! A program that accepts a string of encoded characters and verifies that it
+//! parses, while verifying and logging signers. Currently handles UTF-8
+//! characters.
+
+mod entrypoint;
+pub mod processor;
+
+// Export current sdk types for downstream users building with a different sdk
+// version
+pub use {
+    solana_account_info, solana_instruction, solana_msg, solana_program_entrypoint,
+    solana_program_error, solana_pubkey,
+};
+use {
+    solana_instruction::{AccountMeta, Instruction},
+    solana_pubkey::Pubkey,
+};
+
+/// Legacy symbols from Memo v1
+pub mod v1 {
+    solana_pubkey::declare_id!("Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo");
+}
+
+solana_pubkey::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(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_memo() {
+        let signer_pubkey = Pubkey::new_unique();
+        let memo = "🐆".as_bytes();
+        let instruction = build_memo(memo, &[&signer_pubkey]);
+        assert_eq!(memo, instruction.data);
+        assert_eq!(instruction.accounts.len(), 1);
+        assert_eq!(instruction.accounts[0].pubkey, signer_pubkey);
+    }
+}

program/src/processor.rs

@@ -0,0 +1,107 @@
+//! Program state processor
+
+use {
+    solana_account_info::AccountInfo, solana_msg::msg, solana_program_entrypoint::ProgramResult,
+    solana_program_error::ProgramError, solana_pubkey::Pubkey, 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::*, solana_account_info::IntoAccountInfo, solana_program_error::ProgramError,
+        solana_pubkey::Pubkey, solana_sdk::account::Account,
+    };
+
+    #[test]
+    fn test_utf8_memo() {
+        let program_id = Pubkey::new_from_array([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_from_array([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)
+        );
+    }
+}