token-2022: complete memo extension functionality (#2876)

* Add NoMemo error and use syscall to require memos

* Flesh out + dedupe memo-transfer tests

* Add memo v1 test cases

Author: Tyera Eulberg

Cargo.lock

@@ -18,5 +18,6 @@ async-trait = "0.1"
 solana-program-test = "=1.9.9"
 solana-sdk = "=1.9.9"
 spl-associated-token-account = { version = "1.0.5", path = "../../associated-token-account/program" }
+spl-memo = { version = "3.0.1", path = "../../memo/program", features = ["no-entrypoint"] }
 spl-token-2022 = { version = "0.2", path="../program-2022", features = ["no-entrypoint"] }
 spl-token-client = { version = "0.0.1", path = "../client" }

token/program-2022-test/Cargo.toml

@@ -3,12 +3,28 @@
 mod program_test;
 use {
     program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{pubkey::Pubkey, signature::Signer},
-    spl_token_2022::extension::{memo_transfer::MemoTransfer, ExtensionType},
+    solana_program_test::{
+        tokio::{self, sync::Mutex},
+        ProgramTestContext,
+    },
+    solana_sdk::{
+        instruction::InstructionError,
+        pubkey::Pubkey,
+        signature::Signer,
+        system_instruction,
+        transaction::{Transaction, TransactionError},
+        transport::TransportError,
+    },
+    spl_token_2022::{
+        error::TokenError,
+        extension::{memo_transfer::MemoTransfer, ExtensionType},
+    },
+    spl_token_client::token::TokenError as TokenClientError,
+    std::sync::Arc,
 };
 
 async fn test_memo_transfers(
+    context: Arc<Mutex<ProgramTestContext>>,
     token_context: TokenContext,
     alice_account: Pubkey,
     bob_account: Pubkey,
@@ -38,14 +54,102 @@ async fn test_memo_transfers(
     assert!(bool::from(extension.require_incoming_transfer_memos));
 
     // attempt to transfer from alice to bob without memo
-    // TODO: should fail when token/program-2022/src/processor.rs#L376 is completed
+    let err = token
+        .transfer_unchecked(&alice_account, &bob_account, &alice, 10)
+        .await
+        .unwrap_err();
+    assert_eq!(
+        err,
+        TokenClientError::Client(Box::new(TransportError::TransactionError(
+            TransactionError::InstructionError(
+                0,
+                InstructionError::Custom(TokenError::NoMemo as u32)
+            )
+        )))
+    );
+    let bob_state = token.get_account_info(&bob_account).await.unwrap();
+    assert_eq!(bob_state.base.amount, 0);
+
+    // attempt to transfer from alice to bob with misplaced memo, v1 and current
+    let mut memo_ix = spl_memo::build_memo(&[240, 159, 166, 150], &[]);
+    for program_id in [spl_memo::id(), spl_memo::v1::id()] {
+        let mut ctx = context.lock().await;
+        memo_ix.program_id = program_id;
+        #[allow(deprecated)]
+        let instructions = vec![
+            memo_ix.clone(),
+            system_instruction::transfer(&ctx.payer.pubkey(), &alice.pubkey(), 42),
+            spl_token_2022::instruction::transfer(
+                &spl_token_2022::id(),
+                &alice_account,
+                &bob_account,
+                &alice.pubkey(),
+                &[],
+                10,
+            )
+            .unwrap(),
+        ];
+        let tx = Transaction::new_signed_with_payer(
+            &instructions,
+            Some(&ctx.payer.pubkey()),
+            &[&ctx.payer, &alice],
+            ctx.last_blockhash,
+        );
+        let err: TransactionError = ctx
+            .banks_client
+            .process_transaction(tx)
+            .await
+            .unwrap_err()
+            .unwrap()
+            .into();
+        drop(ctx);
+        assert_eq!(
+            err,
+            TransactionError::InstructionError(
+                2,
+                InstructionError::Custom(TokenError::NoMemo as u32)
+            )
+        );
+        let bob_state = token.get_account_info(&bob_account).await.unwrap();
+        assert_eq!(bob_state.base.amount, 0);
+    }
+
+    // transfer with memo
     token
+        .with_memo("🦖")
         .transfer_unchecked(&alice_account, &bob_account, &alice, 10)
         .await
         .unwrap();
     let bob_state = token.get_account_info(&bob_account).await.unwrap();
     assert_eq!(bob_state.base.amount, 10);
 
+    // transfer with memo v1
+    let mut ctx = context.lock().await;
+    memo_ix.program_id = spl_memo::v1::id();
+    #[allow(deprecated)]
+    let instructions = vec![
+        memo_ix,
+        spl_token_2022::instruction::transfer(
+            &spl_token_2022::id(),
+            &alice_account,
+            &bob_account,
+            &alice.pubkey(),
+            &[],
+            11,
+        )
+        .unwrap(),
+    ];
+    let tx = Transaction::new_signed_with_payer(
+        &instructions,
+        Some(&ctx.payer.pubkey()),
+        &[&ctx.payer, &alice],
+        ctx.last_blockhash,
+    );
+    ctx.banks_client.process_transaction(tx).await.unwrap();
+    drop(ctx);
+    let bob_state = token.get_account_info(&bob_account).await.unwrap();
+    assert_eq!(bob_state.base.amount, 21);
+
     // stop requiring memo transfers into bob_account
     token
         .disable_required_transfer_memos(&bob_account, &bob)
@@ -54,11 +158,11 @@ async fn test_memo_transfers(
 
     // transfer from alice to bob without memo
     token
-        .transfer_unchecked(&alice_account, &bob_account, &alice, 11)
+        .transfer_unchecked(&alice_account, &bob_account, &alice, 12)
         .await
         .unwrap();
     let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, 21);
+    assert_eq!(bob_state.base.amount, 33);
 }
 
 #[tokio::test]
@@ -83,7 +187,7 @@ async fn require_memo_transfers_without_realloc() {
         .await
         .unwrap();
 
-    test_memo_transfers(token_context, alice_account, bob_account).await;
+    test_memo_transfers(context.context, token_context, alice_account, bob_account).await;
 }
 
 #[tokio::test]
@@ -113,5 +217,5 @@ async fn require_memo_transfers_with_realloc() {
         .await
         .unwrap();
 
-    test_memo_transfers(token_context, alice_account, bob_account).await;
+    test_memo_transfers(context.context, token_context, alice_account, bob_account).await;
 }

token/program-2022-test/tests/memo_transfer.rs

@@ -20,6 +20,7 @@ num-traits = "0.2"
 num_enum = "0.5.4"
 solana-program = "1.9.9"
 solana-zk-token-sdk = "0.6.0"
+spl-memo = { version = "3.0.1", path = "../../memo/program", features = [ "no-entrypoint" ] }
 spl-token = { version = "3.3",  path = "../program", features = ["no-entrypoint"] }
 thiserror = "1.0"
 

token/program-2022/Cargo.toml

@@ -135,6 +135,9 @@ pub enum TokenError {
     /// mint and try again
     #[error("An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again")]
     AccountHasWithheldTransferFees,
+    /// No memo in previous instruction; required for recipient to receive a transfer
+    #[error("No memo in previous instruction; required for recipient to receive a transfer")]
+    NoMemo,
 }
 impl From<TokenError> for ProgramError {
     fn from(e: TokenError) -> Self {

token/program-2022/src/error.rs

@@ -24,6 +24,7 @@ use {
         clock::Clock,
         decode_error::DecodeError,
         entrypoint::ProgramResult,
+        instruction::get_processed_sibling_instruction,
         msg,
         program::{invoke, invoke_signed, set_return_data},
         program_error::{PrintProgramError, ProgramError},
@@ -377,7 +378,16 @@ impl Processor {
         }
 
         if memo_required(&dest_account) {
-            // TODO: use get_processed_instructions syscall to check for memo
+            let is_memo_program = |program_id: &Pubkey| -> bool {
+                program_id == &spl_memo::id() || program_id == &spl_memo::v1::id()
+            };
+            let previous_instruction = get_processed_sibling_instruction(0);
+            match previous_instruction {
+                Some(instruction) if is_memo_program(&instruction.program_id) => {}
+                _ => {
+                    return Err(TokenError::NoMemo.into());
+                }
+            }
         }
 
         source_account.base.amount = source_account
@@ -1398,6 +1408,9 @@ impl PrintProgramError for TokenError {
             TokenError::AccountHasWithheldTransferFees => {
                 msg!("Error: An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again");
             }
+            TokenError::NoMemo => {
+                msg!("Error: No memo in previous instruction; required for recipient to receive a transfer");
+            }
         }
     }
 }