pinocchio

The entrypoint! macro is a convenience macro that sets up the three essential components required for a Solana program execution:

1. program_entrypoint!: Declares the program entrypoint.
2. default_allocator!: Declares the default (bump) global allocator.
3. default_panic_handler!: Declares the default panic "hook" (works with std).

If your program is strictly no_std, you should replace default_panic_handler! with nostd_panic_handler! to define a Rust runtime panic handler.

When using entrypoint!, the instruction input is automatically split into:

• program_id: The address of the program being called.
• accounts: The accounts received by the instruction.
• instruction_data: The data for the instruction.

use pinocchio::{
  AccountView,
  Address,
  entrypoint,
  ProgramResult
};
use solana_program_log::log;

entrypoint!(process_instruction);

pub fn process_instruction(
  program_id: &Address,
  accounts: &mut [AccountView],
  instruction_data: &[u8],
) -> ProgramResult {
  log("Hello from my pinocchio program!");
  Ok(())
}

The Batch instruction (discriminator 255) allows executing multiple Token instructions in a single CPI invocation.

Benefits:

• Efficiency: The base CPI invoke units (currently 1000 CUs) are consumed only once for the entire batch, rather than for every individual instruction. This significantly reduces the Compute Units (CUs) required for complex sequences of token operations.

Workflow:

1. Calculate the required total ACCOUNTS_LEN and DATA_LEN for all instructions in the batch.
2. Initialize uninitialized arrays for data and accounts using MaybeUninit.
3. Create a Batch instance using Batch::new().
4. Add instructions to the batch using the .into_batch(&mut batch) method instead of calling .invoke() directly.
5. Call batch.invoke() to execute the entire sequence.

use {
  core::mem::MaybeUninit,
  pinocchio_token::instructions::{
    Batch, InitializeAccount, InitializeMint, IntoBatch, MintTo,
  },
};

// Determine the maximum number of accounts and data length required
// for the batch instruction.
const ACCOUNTS_LEN: usize = InitializeMint::ACCOUNTS_LEN
  + InitializeAccount::ACCOUNTS_LEN
  + MintTo::MAX_ACCOUNTS_LEN;

const DATA_LEN: usize = Batch::header_data_len(3)
  + InitializeMint::MAX_DATA_LEN
  + InitializeAccount::DATA_LEN
  + MintTo::DATA_LEN;

// Create uninitialized arrays for the batch instruction.
let mut data = [const { MaybeUninit::uninit() }; DATA_LEN];
let mut instruction_accounts = [const { MaybeUninit::uninit() }; ACCOUNTS_LEN];
let mut accounts = [const { MaybeUninit::uninit() }; ACCOUNTS_LEN];

// Create a new batch instruction with the uninitialized arrays.
let mut batch = Batch::new(&mut data, &mut instruction_accounts, &mut accounts)?;

InitializeMint::new(
  mint_account,
  rent_sysvar,
  9,
  authority,
  Some(authority),
)
.into_batch(&mut batch)?;

InitializeAccount::new(
  token_account,
  mint_account,
  owner,
  rent_sysvar
).into_batch(&mut batch)?;

MintTo::new(
  mint_account,
  token_account,
  authority_account,
  1000
).into_batch(&mut batch)?;

// Invoke the batch instruction to execute all instructions in a single CPI.
batch.invoke()?;

The lazy_program_entrypoint! macro is designed for programs where you want to control exactly when input parsing occurs to save compute units. Instead of parsing all inputs upfront, it provides an InstructionContext that allows you to parse data on demand.

This is ideal for programs with very few instructions. For larger programs, the standard program_entrypoint! is generally easier and more efficient.

Note: lazy_program_entrypoint! does not set up a global allocator or a panic handler. You must explicitly include default_allocator!, no_allocator!, or your own implementation, and a panic handler.

use pinocchio::{
  default_allocator,
  default_panic_handler,
  entrypoint::InstructionContext,
  lazy_program_entrypoint,
  ProgramResult
};

lazy_program_entrypoint!(process_instruction);
default_allocator!();
default_panic_handler!();

pub fn process_instruction(
  mut context: InstructionContext
) -> ProgramResult {
    Ok(())
}

The Batch instruction (discriminator 255) allows executing multiple Token-2022 instructions in a single CPI invocation. This is significantly more compute-unit (CU) efficient because the base CPI invoke units (currently 1000 CUs) are consumed only once for the entire batch, rather than once per instruction.

To use batching:

1. Calculate the required ACCOUNTS_LEN and DATA_LEN by summing the requirements of all intended instructions.
2. Create uninitialized arrays for data, instruction_accounts, and accounts using MaybeUninit.
3. Initialize a Batch instance using Batch::new().
4. Convert individual instructions into the batch using the .into_batch(&mut batch) method.
5. Call batch.invoke() to execute the entire sequence.

use {
  core::mem::MaybeUninit,
  pinocchio_token_2022::instructions::{
    Batch, InitializeAccount, InitializeMint, IntoBatch, MintTo,
  },
};

// 1. Determine maximum lengths
const ACCOUNTS_LEN: usize = InitializeMint::ACCOUNTS_LEN
  + InitializeAccount::ACCOUNTS_LEN
  + MintTo::MAX_ACCOUNTS_LEN;

const DATA_LEN: usize = Batch::header_data_len(3)
  + InitializeMint::MAX_DATA_LEN
  + InitializeAccount::DATA_LEN
  + MintTo::DATA_LEN;

// 2. Create uninitialized arrays
let mut data = [const { MaybeUninit::uninit() }; DATA_LEN];
let mut instruction_accounts = [const { MaybeUninit::uninit() }; ACCOUNTS_LEN];
let mut accounts = [const { MaybeUninit::uninit() }; ACCOUNTS_LEN];

// 3. Create the batch
let mut batch = Batch::new(&mut data, &mut instruction_accounts, &mut accounts)?;

// 4. Add instructions to the batch
InitializeMint::new(
  mint_account,
  rent_sysvar,
  9,
  &authority,
  Some(&authority),
).into_batch(&mut batch)?;

InitializeAccount::new(
  token_account,
  mint_account,
  owner,
  rent_sysvar
).into_batch(&mut batch)?;

MintTo::new(
  mint_account,
  token_account,
  authority_account,
  1000
).into_batch(&mut batch)?;

// 5. Invoke the batch
batch.invoke()?;