feat: Added pinocchio version of transfer-sol program example

Author: 0xzrf

Cargo.toml

@@ -32,6 +32,7 @@ members = [
     "basics/repository-layout/anchor/programs/*",
     "basics/transfer-sol/native/program",
     "basics/transfer-sol/anchor/programs/*",
+    "basics/transfer-sol/pinocchio/program",
     "tokens/token-2022/mint-close-authority/native/program",
     "tokens/token-2022/non-transferable/native/program",
     "tokens/token-2022/default-account-state/native/program",

basics/transfer-sol/pinocchio/package.json

@@ -0,0 +1,22 @@
+{
+  "scripts": {
+    "test": "pnpm ts-mocha -p ./tsconfig.json -t 1000000 ./test/transferSol.test.ts",
+    "build-and-test": "cargo build-sbf --manifest-path=./program/Cargo.toml --sbf-out-dir=./tests/fixtures && pnpm test",
+    "build": "cargo build-sbf --manifest-path=./program/Cargo.toml --sbf-out-dir=./program/target/so",
+    "deploy": "solana program deploy ./program/target/so/hello_solana_program_pinocchio.so"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.47.3"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.0",
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^22.15.2",
+    "chai": "^4.3.4",
+    "mocha": "^9.0.3",
+    "solana-bankrun": "^0.3.0",
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.3.5"
+  }
+}

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

@@ -0,0 +1,13 @@
+[package]
+name = "pinocchio-transfer-sol"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+bytemuck = {version = "1.24.0", features = ["derive"]}
+pinocchio = "0.9.2"
+pinocchio-pubkey = "0.3.0"
+pinocchio-system = "0.3.0"

basics/transfer-sol/pinocchio/program/src/instructions/cpi_transfer.rs

@@ -0,0 +1,39 @@
+use bytemuck::{Pod, Zeroable};
+use {
+    pinocchio::{
+        account_info::AccountInfo, msg, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+    },
+    pinocchio_system::instructions::Transfer,
+};
+#[repr(C)]
+#[derive(Pod, Zeroable, Clone, Copy)]
+pub struct CpiTransferArgs {
+    amount: u64,
+}
+
+pub fn process_cpi_transfer(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    ix_data: &[u8],
+) -> ProgramResult {
+    msg!("TransferSol Instruction: CpiTransfer");
+    if let [sender, receiver, _system_program] = accounts {
+        let mut aligned_ix_buf = [0u8; core::mem::size_of::<CpiTransferArgs>()]; // putting raw ix_data will fail since it started at index 1 of the original instruction_data, so this new allocation is required
+
+        aligned_ix_buf.copy_from_slice(ix_data);
+
+        let params = bytemuck::try_from_bytes::<CpiTransferArgs>(&aligned_ix_buf)
+            .map_err(|_| ProgramError::InvalidInstructionData)?;
+
+        // sol_log_64(params.amount, 0, 0, 0, 0);
+
+        Transfer {
+            from: sender,
+            lamports: params.amount,
+            to: receiver,
+        }
+        .invoke()?;
+    }
+
+    Ok(())
+}

basics/transfer-sol/pinocchio/program/src/instructions/mod.rs

@@ -0,0 +1,19 @@
+use pinocchio::program_error::ProgramError;
+
+pub mod cpi_transfer;
+
+#[repr(u8)]
+pub enum TransferSolInstructions {
+    CpiTransfer,
+}
+
+impl TryFrom<&u8> for TransferSolInstructions {
+    type Error = ProgramError;
+
+    fn try_from(value: &u8) -> Result<Self, Self::Error> {
+        match *value {
+            0 => Ok(TransferSolInstructions::CpiTransfer),
+            _ => Err(ProgramError::InvalidInstructionData),
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+#![no_std]
+use pinocchio::{no_allocator, nostd_panic_handler, program_entrypoint};
+use pinocchio_pubkey::declare_id;
+mod processor;
+use processor::process_instruction;
+mod instructions;
+
+declare_id!("8TpdLD58VBWsdzxRi2yRcmKJD9UcE2GuUrBwsyCwpbUN");
+
+program_entrypoint!(process_instruction);
+no_allocator!();
+nostd_panic_handler!();

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

@@ -0,0 +1,22 @@
+use crate::instructions::{cpi_transfer::*, TransferSolInstructions};
+use pinocchio::{
+    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+};
+
+pub fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    ix_data: &[u8],
+) -> ProgramResult {
+    let (disc, ix_args) = ix_data
+        .split_first()
+        .ok_or(ProgramError::InvalidInstructionData)?;
+
+    match TransferSolInstructions::try_from(disc)? {
+        TransferSolInstructions::CpiTransfer => {
+            process_cpi_transfer(program_id, accounts, ix_args)?
+        }
+    }
+
+    Ok(())
+}

basics/transfer-sol/pinocchio/test/transferSol.test.ts

@@ -0,0 +1,106 @@
+import {
+  PublicKey,
+  Transaction,
+  TransactionInstruction,
+  Keypair,
+  SystemProgram,
+  LAMPORTS_PER_SOL,
+} from "@solana/web3.js";
+import pkg from "@solana/web3.js";
+import { assert } from "chai";
+import { test } from "mocha";
+import { ProgramTestContext, start } from "solana-bankrun";
+import BN from "bn.js";
+describe("Transfer Sol Tests", () => {
+  const programId = new PublicKey(
+    "8TpdLD58VBWsdzxRi2yRcmKJD9UcE2GuUrBwsyCwpbUN",
+  );
+
+  test("Test Cpi Transfer Works", async () => {
+    const context = await start(
+      [{ programId, name: "./program/target/deploy/pinocchio_transfer_sol" }],
+      [],
+    );
+
+    const client = context.banksClient;
+    const payer = context.payer;
+    const blockhash = context.lastBlockhash;
+
+    const param = { amount: LAMPORTS_PER_SOL };
+
+    const ix_data_buffer = Buffer.concat([
+      Uint8Array.from([0]),
+      Uint8Array.from(new BN(param.amount).toArray("le", 8)),
+    ]);
+    const sender = Keypair.generate();
+    const receiver = PublicKey.unique();
+
+    const initialCredit: any = {
+      fromPubkey: payer.publicKey,
+      lamports: 1.5 * LAMPORTS_PER_SOL,
+      toPubkey: sender.publicKey,
+    };
+
+    const ix1 = [SystemProgram.transfer(initialCredit)];
+
+    const tx1 = new Transaction();
+    tx1.recentBlockhash = blockhash;
+    tx1.add(...ix1);
+
+    tx1.sign(payer);
+
+    await client.simulateTransaction(tx1);
+    await client.processTransaction(tx1);
+    const ix2 = [
+      new TransactionInstruction({
+        programId,
+        keys: [
+          { pubkey: sender.publicKey, isSigner: true, isWritable: true },
+          { pubkey: receiver, isSigner: false, isWritable: true },
+          {
+            pubkey: SystemProgram.programId,
+            isSigner: false,
+            isWritable: false,
+          },
+        ],
+        data: ix_data_buffer,
+      }),
+    ];
+
+    const tx2 = new Transaction();
+    tx2.recentBlockhash = blockhash;
+    tx2.add(...ix2);
+    tx2.feePayer = payer.publicKey;
+    tx2.sign(sender, payer);
+
+    const senderBalanceBefore = await client.getBalance(
+      sender.publicKey,
+      "finalized",
+    );
+    await client.simulateTransaction(tx2, "finalized");
+    const processedTxn = await client.processTransaction(tx2);
+
+    assert(
+      processedTxn.logMessages[0].startsWith(`Program ${programId.toString()}`),
+    );
+
+    assert(
+      processedTxn.logMessages[processedTxn.logMessages.length - 1] ==
+        `Program ${programId.toString()} success`,
+    );
+
+    const senderBalanceAfter = await client.getBalance(
+      sender.publicKey,
+      "finalized",
+    );
+    const receiverBalanceAfter = await client.getBalance(receiver, "finalized");
+
+    assert(receiverBalanceAfter.toString() == param.amount.toString());
+
+    assert(
+      new BN(senderBalanceBefore)
+        .sub(new BN(senderBalanceAfter))
+        .eq(new BN(param.amount)),
+    );
+  });
+});

basics/transfer-sol/pinocchio/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "types": ["mocha", "chai", "node"],
+    "typeRoots": ["./node_modules/@types"],
+    "lib": ["es2015"],
+    "module": "commonjs",
+    "target": "es6",
+    "esModuleInterop": true
+  }
+}