Node Reference

Complete reference for every node type in Solana Contract Flow.

Program Node

The root node of every flow. Exactly one Program node is required per flow. It defines the top-level program metadata.

Fields

Connections

• Output (bottom): connects to Instruction nodes
• No inputs

What It Generates

Anchor:

declare_id!("ProgramIdHere");

#[program]
pub mod my_program {
    use super::*;
    // instruction entry points...
}

Pinocchio:

solana_address::declare_id!("ProgramIdHere");
pinocchio::program_entrypoint!(process_instruction);

Quasar:

declare_id!("ProgramIdHere");

#[program]
pub mod my_program {
    use super::*;
    // instruction logic inline...
}

Instruction Node

Represents a single instruction handler in the program. Each instruction is an entry point that clients can invoke.

Fields

Instruction Arguments

Each argument has:

Supported Types (SolanaType)

**Primitives:** bool, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64, String, Pubkey

Composites:

• { array: [SolanaType, number] } -- fixed-size array, e.g., [u8; 32]
• { vec: SolanaType } -- dynamic vector, e.g., Vec<u64>
• { option: SolanaType } -- optional value, e.g., Option<Pubkey>
• { defined: string } -- user-defined type reference
• { hashMap: [SolanaType, SolanaType] } -- hash map
• { enum: EnumDefinition } -- inline enum

Access Control

Connections

• Input (top): from Program node
• Output right: to Account nodes
• Output bottom: to Logic nodes and Custom Code nodes
• Output left top: to Error nodes
• Output left bottom: to Event nodes

What It Generates

**Anchor:** A separate file src/instructions/<name>.rs with:

pub fn handler(ctx: Context<Initialize>, amount: u64) -> Result<()> {
    // logic body
    Ok(())
}

#[derive(Accounts)]
#[instruction(amount: u64)]
pub struct Initialize<'info> {
    // account fields
}

**Pinocchio:** A separate file src/instructions/<name>.rs with:

pub fn process(
    program_id: &Address,
    accounts: &mut [AccountView],
    data: &[u8],
) -> ProgramResult {
    // account destructuring, validation, logic
    Ok(())
}

**Quasar:** The handler function is generated inline in src/lib.rs within the #[program] block. A separate file contains only the Accounts struct.

Account Node

Represents a Solana account passed to an instruction. This is the most configurable node type.

Account Types (14 types)

Fields

Flags

Contextual Fields (appear based on accountType + flags)

**When isInit or isInitIfNeeded is set:**

**When isClose is set:**

**When accountType is token-account and isInit is set:**

**When accountType is mint and isInit is set:**

**When accountType is associated-token:**

**When accountType is unchecked-account:**

Connections

• Input (top): from Instruction node
• Output (right): to Constraint nodes
• Input (left): from State node

PDA Seeds

When the account is a Program Derived Address, configure seeds:

Each seed has a type and value:

What It Generates

Anchor: Maps to typed account wrappers:

accountType="signer" + isSigner  -> Signer<'info>
accountType="account" + stateType -> Account<'info, MyState>
accountType="system-program"       -> Program<'info, System>
accountType="token-account"        -> Account<'info, TokenAccount>
accountType="mint"                 -> Account<'info, Mint>
accountType="unchecked-account"    -> UncheckedAccount<'info>

**Pinocchio:** All accounts are AccountView. Validation checks are generated explicitly:

if !authority.is_signer() {
    return Err(ProgramError::MissingRequiredSignature);
}
if !vault.is_writable() {
    return Err(ProgramError::InvalidAccountData);
}

Quasar: Uses reference types with mutability in the type:

pub vault: &'info mut Account<Vault>,   // mut + state
pub authority: &'info Signer,            // signer
pub system_program: &'info Program<System>,  // system-program

State Node

Defines an on-chain data structure stored in program-owned accounts.

Fields

State Fields

Each field has:

Connections

• Output (right): to Account node's left (data-in) handle

What It Generates

Anchor:

#[account]
#[derive(InitSpace)]
pub struct Vault {
    pub authority: Pubkey,  // 32 bytes
    pub balance: u64,       // 8 bytes
    #[max_len(64)]
    pub name: String,
}

Pinocchio: Zero-copy struct with byte-offset accessors:

pub struct Vault;

impl Vault {
    pub const LEN: usize = 48; // 8 (disc) + 32 + 8
    const AUTHORITY_OFFSET: usize = 8;
    const BALANCE_OFFSET: usize = 40;

    pub fn authority(data: &[u8]) -> &Address { /* ... */ }
    pub fn set_authority(data: &mut [u8], value: &Address) { /* ... */ }
    pub fn balance(data: &[u8]) -> u64 { /* ... */ }
    pub fn set_balance(data: &mut [u8], value: u64) { /* ... */ }
}

Quasar: Pod-typed struct with explicit discriminator:

#[account(discriminator = [1, 0, 0, 0, 0, 0, 0, 0])]
pub struct Vault {
    pub authority: Address,
    pub balance: PodU64,
}

Constraint Node

Adds a validation rule to an account. Constraints are alternative to flags for more granular control.

All 18 Constraint Types

1. signer

Requires the account to have signed the transaction.

Parameters: None

Generated code:

• Anchor: Type becomes Signer<'info>
• Pinocchio: if !account.is_signer() { return Err(...); }

2. mut

Marks the account as writable.

Parameters: None

Generated code:

• Anchor: #[account(mut)]
• Pinocchio: if !account.is_writable() { return Err(...); }

3. init

Creates a new account funded by a payer with the specified space.

Parameters:

Generated code:

• Anchor: #[account(init, payer = payer, space = 8 + Vault::INIT_SPACE)]
• Pinocchio: CreateAccount { payer, new_account, ... }.invoke()?;

4. init-if-needed

Creates a new account if it doesn't exist, otherwise uses the existing one.

**Parameters:** Same as init

**Note:** In Anchor, this requires the init-if-needed feature flag in Cargo.toml.

5. close

Closes the account and transfers lamports to the target.

Parameters:

Generated code:

• Anchor: #[account(close = sol_destination)]
• Pinocchio: Manual lamport transfer + zeroing

6. has-one

Validates that a field in the account data matches another account's public key.

Parameters:

Generated code:

• Anchor: #[account(has_one = authority)]
• Pinocchio: Manual byte comparison at field offset

7. seeds

Validates the account is a valid PDA derived from the given seeds.

Parameters:

Generated code:

• Anchor: #[account(seeds = [b"vault", authority.key().as_ref()], bump)]
• Pinocchio: crate::utils::verify_pda(account.address(), &[seeds], program_id)?;

8. owner

Validates that the account is owned by a specific program.

Parameters:

Generated code:

• Anchor: #[account(owner = token_program)]
• Pinocchio: if account.owner() != owner.address() { return Err(...); }

9. address

Validates the account's address matches an expected value.

Parameters:

Generated code:

• Anchor: #[account(address = expected_pubkey)]
• Pinocchio: Direct address comparison

10. token-authority

Validates the SPL token account's authority field.

Parameters:

Generated code:

• Anchor: #[account(token::authority = authority)]
• Pinocchio: Manual byte check at offset 32

11. token-mint

Validates the SPL token account's mint field.

Parameters:

Generated code:

• Anchor: #[account(token::mint = mint)]
• Pinocchio: Manual byte check at offset 0

12. mint-authority

Validates the mint's authority field.

Parameters:

Generated code:

• Anchor: #[account(mint::authority = authority)]

13. mint-decimals

Validates the mint's decimals field.

Parameters:

Generated code:

• Anchor: #[account(mint::decimals = 9)]

14. associated-token-authority

Validates the Associated Token Account's authority.

Parameters:

Generated code:

• Anchor: #[account(associated_token::authority = authority)]

15. associated-token-mint

Validates the Associated Token Account's mint.

Parameters:

Generated code:

• Anchor: #[account(associated_token::mint = mint)]

16. realloc

Reallocates account data space.

Parameters:

Generated code:

• Anchor: #[account(realloc = 100, realloc::payer = payer, realloc::zero = false)]

17. safety-comment

Adds a safety justification comment (for unchecked accounts or auditing).

Parameters:

Generated code:

• Anchor: /// CHECK: This account is validated by the program logic
• Pinocchio: // Safety: This account is validated by the program logic

18. custom

A custom constraint expression.

Parameters:

Generated code:

• Anchor: #[account(constraint = account.data.len() > 0 @ MyError::InvalidData)]
• Pinocchio: if !(expression) { return Err(...); }

Error Node

Defines a custom error variant for the program.

Fields

Connections

• Input (left): from Instruction node's error-out handle

What It Generates

Anchor:

#[error_code]
pub enum MyProgramError {
    #[msg("Insufficient funds for this operation")]
    InsufficientFunds,
}

Pinocchio:

pub enum MyProgramError {
    InsufficientFunds = 6000,
}

impl From<MyProgramError> for ProgramError {
    fn from(e: MyProgramError) -> Self {
        ProgramError::Custom(e as u32)
    }
}

Quasar:

#[error_code]
pub enum MyProgramError {
    InsufficientFunds = 6000,
}

Event Node

Defines an event that instructions can emit.

Fields

Connections

• Input (left): from Instruction node's event-out handle

What It Generates

Anchor:

#[event]
pub struct TransferEvent {
    pub from: Pubkey,
    pub to: Pubkey,
    pub amount: u64,
}

Pinocchio:

pub struct TransferEvent {
    pub from: Address,
    pub to: Address,
    pub amount: u64,
}
// Emitted via sol_log_data

Quasar:

#[event(discriminator = 0)]
pub struct TransferEvent {
    pub from: Address,
    pub to: Address,
    pub amount: u64,
}

Logic Node

Defines an operation in the instruction body. This is the executable logic of your program.

All 12 Logic Operations

1. set-field

Sets a field on an account's data.

Generated code:

// Anchor
vault.balance = new_amount;

// Pinocchio
Vault::set_balance(&mut vault.try_borrow_mut_data()?, new_amount);

// Quasar
vault.balance = PodU64::from(new_amount);

2. transfer-sol

Transfers SOL from one account to another.

Generated code:

// Anchor — system program CPI
anchor_lang::system_program::transfer(cpi_ctx, amount)?;

// Pinocchio — pinocchio_system
Transfer { from, to, lamports: amount }.invoke()?;

// Quasar — system program method
ctx.accounts.system_program.transfer(from, to, amount).invoke()?;

3. transfer-token

Transfers SPL tokens.

4. mint-to

Mints new tokens.

5. burn

Burns tokens.

6. require

Validates a condition. Returns an error if the condition is false.

Generated code:

// Anchor
require!(balance >= amount, MyProgramError::InsufficientFunds);

// Pinocchio
if !(balance >= amount) {
    return Err(MyProgramError::InsufficientFunds.into());
}

// Quasar
require!(balance >= amount, MyProgramError::InsufficientFunds);

7. if-else

Conditional branching. Child logic nodes connected to this node form the "then" and "else" branches.

Child connections:

• Connect to the default (bottom) handle for the "then" branch
• Connect to the "else-out" handle for the "else" branch

Generated code:

if condition {
    // then body
} else {
    // else body
}

8. emit-event

Emits a program event.

Generated code:

// Anchor & Quasar
emit!(TransferEvent {
    from: sender.key(),
    to: receiver.key(),
    amount: amt,
});

// Pinocchio
pinocchio::log::sol_log_data(&[&[]]);

9. return-error

Returns a custom error from the instruction.

Generated code:

// Anchor
return err!(MyProgramError::Unauthorized);

// Pinocchio
return Err(MyProgramError::Unauthorized.into());

// Quasar
return Err(MyProgramError::Unauthorized.into());

10. math

Performs arithmetic.

Generated code (checked):

// Anchor
let result = left.checked_add(right).ok_or(ErrorCode::ArithmeticOverflow)?;

// Pinocchio & Quasar
let result = left.checked_add(right).ok_or(ProgramError::ArithmeticOverflow)?;

Generated code (unchecked):

let result = left + right;

11. cpi

Cross-Program Invocation. Calls an instruction on another program.

12. custom-code

Injects raw Rust code into the instruction body.

The code is inserted verbatim. Use this for logic that cannot be expressed with other node types.

Custom Code Node

A special node for injecting raw Rust code. Behaves like a Logic node but with freeform code.

Fields

Connections

• Input (top): from Instruction or Logic node
• Output (bottom): to Logic node
• Input (left): receives variable bindings
• Output (right): produces variable bindings

Integration Node

Plugin integration point for extending code generation with custom logic.

Fields

Connections

• Input (top): from Instruction node
• Output (bottom): to Account node