transfer

Author: jpcaulfi

basics/transfer-sol/anchor/programs/transfer-sol/src/lib.rs

@@ -1,17 +1,18 @@
 use anchor_lang::prelude::*;
 use anchor_lang::system_program;
 
+
 declare_id!("4fQVnLWKKKYxtxgGn7Haw8v2g2Hzbu8K61JvWKvqAi7W");
 
+
 #[program]
 pub mod transfer_sol {
  use super::*;
 
- pub fn transfer_sol(ctx: Context<TransferSol>, amount: u64) -> Result<()> {
- 
- msg!("Received request to transfer {:?} lamports from {:?} to {:?}.", 
- amount, &ctx.accounts.payer.key(), &ctx.accounts.recipient.key());
- msg!(" Processing transfer...");
+ pub fn transfer_sol_with_cpi(
+ ctx: Context<TransferSolWithCpi>, 
+ amount: u64
+ ) -> Result<()> {
 
  system_program::transfer(
  CpiContext::new(
@@ -23,18 +24,42 @@ pub mod transfer_sol {
  ),
  amount,
  )?;
+
+ Ok(())
+ }
+
+ pub fn transfer_sol_with_program(
+ ctx: Context<TransferSolWithProgram>, 
+ amount: u64
+ ) -> Result<()> {
+
+ **ctx.accounts.payer
+ .to_account_info()
+ .try_borrow_mut_lamports()? -= amount;
+ **ctx.accounts.recipient
+ .to_account_info()
+ .try_borrow_mut_lamports()? += amount;
 
- msg!("Transfer completed successfully.");
  Ok(())
  }
 }
 
 #[derive(Accounts)]
-pub struct TransferSol<'info> {
- /// CHECK: We're initializing this account via the transfer
+pub struct TransferSolWithCpi<'info> {
  #[account(mut)]
- recipient: AccountInfo<'info>,
+ recipient: SystemAccount<'info>,
  #[account(mut)]
  payer: Signer<'info>,
  system_program: Program<'info, System>,
-}
+}
+
+#[derive(Accounts)]
+pub struct TransferSolWithProgram<'info> {
+ /// CHECK: This is just an example, not checking data
+ #[account(mut)]
+ recipient: UncheckedAccount<'info>,
+ /// CHECK: This is just an example, not checking data
+ #[account(mut)]
+ payer: UncheckedAccount<'info>,
+ system_program: Program<'info, System>,
+}

basics/transfer-sol/anchor/tests/test.ts

@@ -5,34 +5,79 @@ describe("transfer-sol", () => {
 
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);
- const wallet = provider.wallet as anchor.Wallet;
+ const payer = provider.wallet as anchor.Wallet;
  const program = anchor.workspace.TransferSol as anchor.Program<TransferSol>;
 
- it("Transfer some SOL", async () => {
+ const transferAmount = 1 * anchor.web3.LAMPORTS_PER_SOL;
+ const test1Recipient = anchor.web3.Keypair.generate();
+ const test2Recipient1 = anchor.web3.Keypair.generate();
+ const test2Recipient2 = anchor.web3.Keypair.generate();
 
- async function getBalances(payerPubkey: anchor.web3.PublicKey, recipientPubkey: anchor.web3.PublicKey, timeframe: string) {
- let payerBalance = await provider.connection.getBalance(payerPubkey);
- let recipientBalance = await provider.connection.getBalance(recipientPubkey);
- console.log(`${timeframe} balances:`);
- console.log(` Payer: ${payerBalance}`);
- console.log(` Recipient: ${recipientBalance}`);
+ it("Transfer between accounts using the system program", async () => {
+
+ await getBalances(payer.publicKey, test1Recipient.publicKey, "Beginning");
+ 
+ await program.methods.transferSolWithCpi(new anchor.BN(transferAmount))
+ .accounts({
+ payer: payer.publicKey,
+ recipient: test1Recipient.publicKey,
+ systemProgram: anchor.web3.SystemProgram.programId,
+ })
+ .signers([payer.payer])
+ .rpc();
+
+ await getBalances(payer.publicKey, test1Recipient.publicKey, "Resulting");
+
+ });
+
+ it("Create two accounts for the following test", async () => {
+
+ const ix = (pubkey: anchor.web3.PublicKey) => {
+ return anchor.web3.SystemProgram.createAccount({
+ fromPubkey: payer.publicKey,
+ newAccountPubkey: pubkey,
+ space: 0,
+ lamports: 2 * anchor.web3.LAMPORTS_PER_SOL,
+ programId: program.programId,
+ })
  };
 
- const recipientKeypair = anchor.web3.Keypair.generate();
- const transferAmount = 1 * anchor.web3.LAMPORTS_PER_SOL;
+ await anchor.web3.sendAndConfirmTransaction(
+ provider.connection,
+ new anchor.web3.Transaction()
+ .add(ix(test2Recipient1.publicKey))
+ .add(ix(test2Recipient2.publicKey))
+ ,
+ [payer.payer, test2Recipient1, test2Recipient2]
+ );
+ });
+
+ it("Transfer between accounts using our program", async () => {
 
- await getBalances(wallet.publicKey, recipientKeypair.publicKey, "Beginning");
+ await getBalances(test2Recipient1.publicKey, test2Recipient2.publicKey, "Beginning");
 
- await program.methods.transferSol(new anchor.BN(transferAmount))
- .accounts({
- payer: wallet.publicKey,
- recipient: recipientKeypair.publicKey,
- systemProgram: anchor.web3.SystemProgram.programId,
- })
- .signers([wallet.payer])
- .rpc();
+ await program.methods.transferSolWithProgram(new anchor.BN(transferAmount))
+ .accounts({
+ payer: test2Recipient1.publicKey,
+ recipient: test2Recipient2.publicKey,
+ systemProgram: anchor.web3.SystemProgram.programId,
+ })
+ .rpc();
 
- await getBalances(wallet.publicKey, recipientKeypair.publicKey, "Resulting");
+ await getBalances(test2Recipient1.publicKey, test2Recipient2.publicKey, "Resulting");
 
  });
+
+ async function getBalances(
+ payerPubkey: anchor.web3.PublicKey, 
+ recipientPubkey: anchor.web3.PublicKey, 
+ timeframe: string
+ ) {
+
+ let payerBalance = await provider.connection.getBalance(payerPubkey);
+ let recipientBalance = await provider.connection.getBalance(recipientPubkey);
+ console.log(`${timeframe} balances:`);
+ console.log(` Payer: ${payerBalance}`);
+ console.log(` Recipient: ${recipientBalance}`);
+ };
 });

basics/transfer-sol/native/program/Cargo.toml

@@ -4,6 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+borsh = "0.9.3"
+borsh-derive = "0.9.1"
 solana-program = "1.10.12"
 
 [lib]

basics/transfer-sol/native/program/src/instruction.rs

@@ -0,0 +1,42 @@
+use solana_program::{
+ account_info::{ AccountInfo, next_account_info }, 
+ entrypoint::ProgramResult, 
+ program::invoke,
+ pubkey::Pubkey,
+ system_instruction,
+};
+
+
+pub fn transfer_sol_with_cpi(
+ accounts: &[AccountInfo],
+ amount: u64,
+) -> ProgramResult {
+
+ let accounts_iter = &mut accounts.iter();
+ let payer = next_account_info(accounts_iter)?;
+ let recipient = next_account_info(accounts_iter)?;
+ let system_program = next_account_info(accounts_iter)?;
+
+ invoke(
+ &system_instruction::transfer(payer.key, recipient.key, amount),
+ &[payer.clone(), recipient.clone(), system_program.clone()],
+ )?;
+ 
+ Ok(())
+}
+
+pub fn transfer_sol_with_program(
+ program_id: &Pubkey,
+ accounts: &[AccountInfo],
+ amount: u64,
+) -> ProgramResult {
+
+ let accounts_iter = &mut accounts.iter();
+ let payer = next_account_info(accounts_iter)?;
+ let recipient = next_account_info(accounts_iter)?;
+
+ **payer.try_borrow_mut_lamports()? -= amount;
+ **recipient.try_borrow_mut_lamports()? += amount;
+ 
+ Ok(())
+}

basics/transfer-sol/native/program/src/lib.rs

@@ -1,48 +1,10 @@
-use {
- std::convert::TryInto,
- solana_program::{
- account_info::{
- next_account_info, AccountInfo
- },
- entrypoint,
- entrypoint::ProgramResult,
- msg,
- program::invoke,
- program_error::ProgramError,
- pubkey::Pubkey,
- system_instruction,
- },
-};
-
-
-entrypoint!(process_instruction);
-
 
-fn process_instruction(
- _program_id: &Pubkey,
- accounts: &[AccountInfo],
- instruction_data: &[u8],
-) -> ProgramResult {
+pub mod instruction;
+pub mod processor;
 
- let accounts_iter = &mut accounts.iter();
- let payer = next_account_info(accounts_iter)?;
- let recipient = next_account_info(accounts_iter)?;
-
- let amount = instruction_data
- .get(..8)
- .and_then(|slice| slice.try_into().ok())
- .map(u64::from_le_bytes)
- .ok_or(ProgramError::InvalidInstructionData)?;
-
- msg!("Received request to transfer {:?} lamports from {:?} to {:?}.", 
- amount, payer.key, recipient.key);
- msg!(" Processing transfer...");
+use {
+ solana_program::entrypoint,
+ crate::processor::process_instruction,
+};
 
- invoke(
- &system_instruction::transfer(payer.key, recipient.key, amount),
- &[payer.clone(), recipient.clone()],
- )?;
- 
- msg!("Transfer completed successfully.");
- Ok(())
-}
+entrypoint!(process_instruction);

basics/transfer-sol/native/program/src/processor.rs

@@ -0,0 +1,32 @@
+use borsh::{ BorshDeserialize, BorshSerialize };
+use solana_program::{
+ account_info::AccountInfo, 
+ entrypoint::ProgramResult, 
+ pubkey::Pubkey,
+};
+
+use crate::instruction::transfer_sol_with_cpi;
+use crate::instruction::transfer_sol_with_program;
+
+
+#[derive(BorshSerialize, BorshDeserialize, Debug)]
+pub enum TransferInstruction {
+ CpiTransfer(u64),
+ ProgramTransfer(u64),
+}
+
+
+pub fn process_instruction(
+ program_id: &Pubkey,
+ accounts: &[AccountInfo],
+ input: &[u8],
+) -> ProgramResult {
+
+ let instruction = TransferInstruction::try_from_slice(&input)?;
+ match instruction {
+ TransferInstruction::CpiTransfer(
+ args) => transfer_sol_with_cpi(accounts, args),
+ TransferInstruction::ProgramTransfer(
+ args) => transfer_sol_with_program(program_id, accounts, args),
+ }
+}

basics/transfer-sol/native/tests/instruction.ts

@@ -0,0 +1,72 @@
+import * as borsh from "borsh";
+import { Buffer } from "buffer";
+import { 
+ PublicKey, 
+ SystemProgram,
+ TransactionInstruction 
+} from '@solana/web3.js';
+
+
+export enum InstructionType {
+ CpiTransfer,
+ ProgramTransfer,
+}
+
+
+export class TransferInstruction {
+
+ instruction: InstructionType;
+ amount: number;
+
+ constructor(props: {
+ instruction: InstructionType,
+ amount: number,
+ }) {
+ this.instruction = props.instruction;
+ this.amount = props.amount;
+ }
+
+ toBuffer() { 
+ return Buffer.from(borsh.serialize(TransferInstructionSchema, this)) 
+ };
+ 
+ static fromBuffer(buffer: Buffer) {
+ return borsh.deserialize(TransferInstructionSchema, TransferInstruction, buffer);
+ };
+};
+
+export const TransferInstructionSchema = new Map([
+ [ TransferInstruction, { 
+ kind: 'struct', 
+ fields: [ 
+ ['instruction', 'u8'],
+ ['amount', 'u64'],
+ ],
+ }]
+]);
+
+export function createTransferInstruction(
+ payerPubkey: PublicKey,
+ recipientPubkey: PublicKey,
+ programId: PublicKey,
+ instruction: InstructionType,
+ amount: number,
+): TransactionInstruction {
+
+ const instructionObject = new TransferInstruction({
+ instruction,
+ amount,
+ });
+
+ const ix = new TransactionInstruction({
+ keys: [
+ {pubkey: payerPubkey, isSigner: true, isWritable: true},
+ {pubkey: recipientPubkey, isSigner: false, isWritable: true},
+ {pubkey: SystemProgram.programId, isSigner: false, isWritable: false}
+ ],
+ programId,
+ data: instructionObject.toBuffer(),
+ });
+
+ return ix;
+}