ported memo to anchor

memo/anchor_program/memo/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "memo"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "memo"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+anchor-lang = "0.22.0"

memo/anchor_program/memo/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

memo/anchor_program/memo/src/lib.rs

@@ -0,0 +1,50 @@
+use anchor_lang::prelude::*;
+
+declare_id!("4ARKJpztrkSJXJQ8ii9pr6NjJdwKrC6M3jA8LG21tvjG");
+
+#[program]
+pub mod memo {
+    use super::*;
+    use std::str;
+    pub fn build_memo(ctx: Context<BuildMemo>,input:Vec<u8>) -> Result<()> {
+
+        msg!("Initializing");
+
+        let accounts = ctx.remaining_accounts;
+
+        let mut missing_required_signature = false;
+        for account_info in accounts.iter() {
+            if let Some(address) = account_info.signer_key() {
+                msg!("Signed by: {:?}", address);
+            }
+            else{
+                missing_required_signature = true;
+            }
+        }
+        if missing_required_signature{
+            return err!(MyError::MissingRequiredSignature);
+        }
+
+        let memo = str::from_utf8(&input).map_err(|err| {
+            msg!("Invalid UTF-8, from bytes: {:?}", err);
+            ProgramError::InvalidInstructionData
+        })?;
+        msg!("Memo (len {}): {:?}", memo.len(), memo);
+        Ok(())
+    }   
+}
+
+#[derive(Accounts)]
+pub struct BuildMemo<> {
+
+}
+
+
+#[error_code]
+pub enum MyError {
+    #[msg("Missing required signature")]
+    MissingRequiredSignature,
+    #[msg("Invalid Instruction Data")]
+    InvalidInstructionData
+}
+

memo/anchor_program/tests/memo.js

@@ -0,0 +1,98 @@
+const anchor = require("@project-serum/anchor");
+const assert = require("assert");
+
+describe("memo", () => {
+  // Configure the client to use the local cluster.
+  anchor.setProvider(anchor.Provider.env());
+  const program = anchor.workspace.Memo;
+
+  it("Test 1 => Sending Buffers", async () => {
+    const string = "letters";
+    var codedString = Buffer.from(string);
+
+    const tx = await program.rpc.buildMemo(codedString);
+    console.log("Transaction Signature:", tx);
+  });
+
+  it("Test 2 => Asserting Emojis and Bytes", async () => {
+    let emoji = Uint8Array.from(Buffer.from("🐆"));
+    let bytes = Uint8Array.from([0xf0, 0x9f, 0x90, 0x86]);
+    assert.equal(emoji.toString(), bytes.toString());
+
+    const tx1 = await program.rpc.buildMemo(Buffer.from("🐆"));
+
+    const tx2 = await program.rpc.buildMemo(Buffer.from(bytes));
+    console.log("Transaction Signature One:", tx1);
+    console.log("Transaction Signature Two:", tx2);
+  });
+
+  it("Test 3 => Sending Signed Transaction", async () => {
+    const pubkey1 = anchor.web3.Keypair.generate();
+    const pubkey2 = anchor.web3.Keypair.generate();
+    const pubkey3 = anchor.web3.Keypair.generate();
+
+    const tx = await program.rpc.buildMemo(Buffer.from("🐆"), {
+      accounts: [],
+      remainingAccounts: [
+        { pubkey: pubkey1.publicKey, isWritable: false, isSigner: true },
+        { pubkey: pubkey2.publicKey, isWritable: false, isSigner: true },
+        { pubkey: pubkey3.publicKey, isWritable: false, isSigner: true },
+      ],
+      signers: [pubkey1, pubkey2, pubkey3],
+    });
+    console.log("Transaction Signature:", tx);
+  });
+
+  it("Test 4 => Sending Unsigned Transaction with a Memo", async () => {
+    // This test should fail because the transaction is not signed.
+    const pubkey1 = anchor.web3.Keypair.generate();
+    const pubkey2 = anchor.web3.Keypair.generate();
+    const pubkey3 = anchor.web3.Keypair.generate();
+
+    assert.rejects(() => {
+      program.rpc.buildMemo(Buffer.from("🐆"), {
+        accounts: [],
+        remainingAccounts: [
+          { pubkey: pubkey1.publicKey, isWritable: false, isSigner: false },
+          { pubkey: pubkey2.publicKey, isWritable: false, isSigner: false },
+          { pubkey: pubkey3.publicKey, isWritable: false, isSigner: false },
+        ],
+        signers: [pubkey1, pubkey2, pubkey3],
+      });
+    }, new Error("unknown signer"));
+
+    console.log("Test failed successfully :)");
+  });
+
+  it("Test 5 => Sending a transaction with missing signers", async () => {
+    // This test should fail because the transaction is not signed completely.
+    const pubkey1 = anchor.web3.Keypair.generate();
+    const pubkey2 = anchor.web3.Keypair.generate();
+    const pubkey3 = anchor.web3.Keypair.generate();
+
+    assert.rejects(async () => {
+      await program.rpc.buildMemo(Buffer.from("🐆"), {
+        accounts: [],
+        remainingAccounts: [
+          { pubkey: pubkey1.publicKey, isWritable: false, isSigner: true },
+          { pubkey: pubkey2.publicKey, isWritable: false, isSigner: false },
+          { pubkey: pubkey3.publicKey, isWritable: false, isSigner: true },
+        ],
+        signers: [pubkey1, pubkey2, pubkey3],
+      });
+    }, new Error("unknown signer"));
+    console.log("Test failed successfully :)");
+  });
+
+  it("Test 6 => Testing invalid input", async () => {
+    // This test should fail because the input is invalid.
+    let invalid_utf8 = Uint8Array.from([
+      0xf0, 0x9f, 0x90, 0x86, 0xf0, 0x9f, 0xff, 0x86,
+    ]);
+
+    assert.rejects(() => {
+      program.rpc.buildMemo(Buffer.from(invalid_utf8));
+    }, new Error());
+    console.log("Test failed successfully :)");
+  });
+});