A guide to build an encrypted email service on Solana with Anchor

[dependencies]uuid = { version = "0.8.*", features = ["serde", "v5"] }anchor-lang = "0.22.1"

... src   context.rs -> contexts of instructions   error.rs -> error structs   lib.rs -> contains all the instructions   state.rs -> state structs   utils.rs -> helpers functions...

use anchor_lang::prelude::*;#[account]pub struct Mail {    pub from: Pubkey,    pub to: Pubkey,    pub id: String,    pub subject: String,    /* encrypted text */    pub body: String,    pub authority: Pubkey,    pub created_at: u32,    /* public information about encryption and decryption */    pub iv: String,    pub salt: String,}#[account]pub struct UserAccount {    /* pubkey from diffie helman exchange */    pub diffie_pubkey: String,    pub authority: Pubkey,    pub bump: u8,}/* this event allows us to notify clients *//* when a new email is created */#[event]pub struct NewEmailEvent {    pub from: Pubkey,    pub to: Pubkey,    pub id: String,}

use crate::state::{Mail, UserAccount};use anchor_lang::prelude::*;#[derive(Accounts)]pub struct SendMail<'info> {    #[account(        init,        payer = authority,        space =            8 +       // discriminator            32 +      // from            32 +      // to            34 +      // id            40 +      // subject            512 +     // body            32 +      // authority            4 +       // created_at            20 +      // salt            36        // iv    )]    pub mail: Account<'info, Mail>,    pub system_program: Program<'info, System>,    #[account(mut)]    pub authority: Signer<'info>,}#[derive(Accounts)]pub struct Register<'info> {    #[account(mut)]    pub authority: Signer<'info>,    #[account(        init,        payer = authority,        space =            8  +          // discriminator            4  + 64 +     // public key            32 +          // authority            1,            // bump       seeds = [b"user-account", authority.key().as_ref()],       bump    )]    pub user_account: Account<'info, UserAccount>,    pub system_program: Program<'info, System>,}/* helper table for calculating accounts spaces *//*    bool            1 byte      1 bit rounded up to 1 byte.    u8 or i8        1 byte    u16 or i16      2 bytes    u32 or i32      4 bytes    u64 or i64      8 bytes    u128 or i128    16 bytes    [u16; 32]       64 bytes    32 items x 2 bytes. [itemSize; arrayLength]    PubKey          32 bytes    Same as [u8; 32]    vec<u16>        Any multiple of 2 bytes + 4 bytes for the prefix    Need to allocate the maximum amount of item that could be required.    String          Any multiple of 1 byte + 4 bytes for the prefix Same as vec<u8>*/

use anchor_lang::prelude::*;#[error_code]pub enum ErrorCode {    #[msg("Invalid instruction")]    InvalidInstruction,    #[msg("The body of your email is too long. The max is 512 chars")]    InvalidBody,    #[msg("The subject of your email is too long. The max is 40 chars")]    InvalidSubject,    #[msg("The salt should be exactly 16 chars")]    InvalidSalt,    #[msg("The IV should be exactly 32 chars")]    InvalidIv,    #[msg("The diffie publickey should be exactly 64 chars")]    InvalidDiffie,}

use anchor_lang::prelude::Pubkey;use uuid::Uuid;/* creates a unique ID for a mail using now, body, and sender as arguments */pub fn get_uuid(now: &u32, body: &String, sender: &Pubkey) -> String {    const V5NAMESPACE: &Uuid = &Uuid::from_bytes([        16, 92, 30, 120, 224, 152, 10, 207, 140, 56, 246, 228, 206, 99, 196, 138,    ]);    let now = now.to_be_bytes();    let body = body.as_bytes();    let sender = sender.to_bytes();    let mut vec = vec![];    vec.extend_from_slice(&now);    vec.extend_from_slice(&body);    vec.extend_from_slice(&sender);    Uuid::new_v5(V5NAMESPACE, &vec).to_string()}

use {crate::error::ErrorCode, anchor_lang::prelude::*, context::*, utils::*};pub mod context;pub mod error;pub mod state;pub mod utils;declare_id!("9KVS65SWuX5jnmJkzpyXMCdeKpad9G5sSoKopUUgDiA");#[program]pub mod encrypted-mail {    use super::*;    use anchor_lang::Key;    pub fn send_email(        ctx: Context<SendMail>,        subject: String,        body: String,        from: Pubkey,        to: Pubkey,        salt: String,        iv: String    ) -> Result<()> {        require!(subject.chars().count() < 50, ErrorCode::InvalidSubject);        require!(body.chars().count() < 280, ErrorCode::InvalidBody);        require!(salt.chars().count() == 16, ErrorCode::InvalidSalt);        require!(iv.chars().count() == 32, ErrorCode::InvalidIv);        let now = Clock::get().unwrap().unix_timestamp as u32;        let mail = &mut ctx.accounts.mail;        let id = get_uuid(&now, &body, &mail.key());        mail.from = from;        mail.to = to;        mail.id = id.clone();        mail.subject = subject;        mail.body = body; // encrypted body, a ciphertext        mail.created_at = now;        mail.salt = salt;        mail.iv = iv;        mail.authority = *ctx.accounts.authority.key;        emit!(state::NewEmailEvent {            from,            to,            id        });        Ok(())    }pub fn register(ctx: Context<Register>, diffie_pubkey: String) -> Result<()> {        require!(diffie_pubkey.chars().count() == 64, ErrorCode::InvalidDiffie);        let user_account = &mut ctx.accounts.user_account;        user_account.diffie_pubkey = diffie_pubkey;        user_account.authority = *ctx.accounts.authority.key;        user_account.bump = *ctx.bumps.get("user_account").unwrap();        Ok(())    }}

import { PublicKey } from "@solana/web3.js";import { TextEncoder } from "text-encoding";import idl from "./target/idl/minerva.json";import { getProvider } from "@project-serum/anchor";import { ec } from 'elliptic'export const DEVNET_WALLET = getProvider().wallet.publicKey;export const getUserPDA = async (  seed: string,  authority: PublicKey = DEVNET_WALLET) => {  const [PDA] = await PublicKey.findProgramAddress(    [new TextEncoder().encode(seed), authority.toBuffer()],    new PublicKey(idl.metadata.address)  );  return PDA;};export const elliptic = new ec('curve25519')

import {  Program,  workspace,  Provider,  setProvider,} from "@project-serum/anchor";import AES from 'crypto-js/aes'import { enc, mode, lib } from 'crypto-js'import { Keypair, SystemProgram } from "@solana/web3.js";import { EncryptedMail } from "../target/types/encrypted-mail";import { DEVNET_WALLET, getUserPDA, elliptic } from "../utils";import { expect } from "chai";describe("beggining encrypted-mail tests", () => {  setProvider(Provider.env());  /* generating diffie helmann keys */  const aliceKeypair = elliptic.genKeyPair()  const bobKeypair = elliptic.genKeyPair()  const aliceDiffiePublic = aliceKeypair.getPublic().encode("hex", true)  const bobDiffiePublic = bobKeypair.getPublic().encode("hex", true)  const sharedSecret = aliceKeypair.derive(bobKeypair.getPublic()).toString("hex")  /* generating blockchain wallets */  const alice = DEVNET_WALLET;  const bob = Keypair.generate();  const program = workspace.EncryptedMail as Program<EncryptedMail>;}

it("can register alice and bob", async () => {    const aliceAccountPDA = await getUserPDA("user-account");    const bobAccountPDA = await getUserPDA("user-account", bob.publicKey);    const airdropTx = await program.provider.connection.requestAirdrop(      bob.publicKey,      1000000000    );    await program.provider.connection.confirmTransaction(airdropTx);    await program.rpc.register(aliceDiffiePublic, {      accounts: {        authority: alice,        userAccount: aliceAccountPDA,        systemProgram: SystemProgram.programId,      },    });    await program.rpc.register(bobDiffiePublic, {      accounts: {        authority: bob.publicKey,        userAccount: bobAccountPDA,        systemProgram: SystemProgram.programId,      },      signers: [bob]    });    const users = await program.account.userAccount.all();    console.log("users: ", users);    expect(users.length).to.equal(2);  });

it("can encrypt emails, send the emails, and decrypt it", async () => {    const mailA = Keypair.generate();    let cipher = AES.encrypt("simplesmente intankavel o bostil", sharedSecret, { mode: mode.CTR })    await program.rpc.sendEmail(      "very important subject", // subject      cipher.ciphertext.toString(), // body of email      alice, // from      bob.publicKey, // to      cipher.salt.toString(), // salt      cipher.iv.toString(), // iv      {        accounts: {          authority: alice,          mail: mailA.publicKey,          systemProgram: SystemProgram.programId,        },        signers: [mailA],      }    );    const emails = await program.account.mail.all();    const email = emails[0].account    const plaintext = AES.decrypt(      {        ciphertext: enc.Hex.parse(email.body),        iv: enc.Hex.parse(email.iv),        salt: enc.Hex.parse(email.salt)      } as lib.CipherParams,      sharedSecret,      { mode: mode.CTR }    )    console.log("
");    console.log("emails: ", emails);    console.log("
");    console.log('plaintext: ', plaintext.toString(enc.Utf8))    console.log("shared_secret: ", sharedSecret);    console.log("cyphertext: ", emails[0].account.body);    console.log("
");    expect(plaintext.toString(enc.Utf8)).to.equal('simplesmente intankavel o bostil');  });

[programs.localnet]encrypted-mail = "9KVS65SWuX5jnmJkzpyXMCdeKpad9G5sSoKopUUgDiA"[programs.devnet]encrypted-mail = "9KVS65SWuX5jnmJkzpyXMCdeKpad9G5sSoKopUUgDiA"[registry]url = "https://anchor.projectserum.com"[provider]cluster = "localnet"wallet = "~/.config/solana/devnet.json"[scripts]test = "npx ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"