Cross-Program Invocations in Solana: Building a Puppet Program

In Rust, structs define complex data types with PascalCase names and snake_case fields, where methods are implemented externally using impl blocks; traits enable polymorphism by defining shared behaviors that multiple structs can implement, while derive macros automatically implement common traits like Debug for convenience.

Rust structs define data structures with named fields. To overload operators like +, implement traits from std::ops (like Add), requiring an associated output type and add method implementation. Derive macros automatically generate boilerplate code—for example, deriving Debug generates debug printing, and deriving Copy enables implicit copying for small types. Move semantics transfer ownership when passing values without references, consuming the original variable. This differs from languages where passing parameters creates copies. References (&T) allow borrowing without transferring ownership, with immutable or mutable variants. The compiler enforces that references cannot outlive their owning variables and that aliasing and mutability cannot occur simultaneously, preventing data races.

Rust's ownership system manages memory without garbage collection. Rules: every value has one owner, only one owner at a time, owner destruction frees memory. Move semantics transfer ownership rather than copying. Structures are user-defined types with fields of different types, declared with struct keyword. Syntax: struct Name { field1: type1, field2: type2 }. Instances are created with Name { field1: value1, field2: value2 }. Functions can accept structure parameters.

Ownership is Rust's core mechanism for managing memory safely. Each piece of data has exactly one owner at any time. When data is passed to a function, ownership transfers, and the original owner can no longer use it. This prevents use-after-free errors at compile time. Ownership propagates deeply through composite structures—if a field is moved, the entire struct becomes invalid for accessing that field. This eliminates the need for manual memory management while providing precise control over resource lifetimes.

Rust programs always start with a main function. The language is biased toward safety by default, with variables being immutable unless explicitly made mutable. Macros like println! use exclamation marks to indicate they are special compiler instructions. Rust uses traits (similar to interfaces in object-oriented languages) to provide methods to types. When you use ampersand mut (&mut), you request a mutable reference. Rust is not object-oriented; it uses traits instead of classes. Importing the right trait into local scope gives access to its methods.

The Anchor framework consists of four main components: (1) Program - the main smart contract code containing functions like create, read, update, delete, (2) Context Definitions - defines the account structures passed to each function, (3) Custom Errors - defines error codes for the program, (4) Custom Account Definitions - defines the structure of accounts the program will create or use. Custom accounts are defined using the 'account' macro and contain structured data fields. The example account structure includes: ID (u64), Owner (Pubkey), and Content (String). The owner field is important because only the owner can modify the account's data, providing access control.

Anchor simplifies Solana smart contract development using Rust macros. The account macro defines account structures and properties (mutable, init). The derive account macro creates instruction contexts listing all related accounts. The program macro marks modules as Solana programs, converting functions into instruction entry points.

The Anchor framework accelerates Solana smart contract development by abstracting low-level complexities including serialization/deserialization and security checks. Required installations include Rust, Solana CLI, yarn, and Anchor. Key CLI commands are anchor init, build, deploy, and test. Program modules use #[program] annotations with individual instruction functions. Account management employs derive(Account) structs with init, mut, and signer attributes. Space allocation requires precise byte calculations (8 bytes for hash + data size). Anchor automatically verifies account ownership and handles rent payments, eliminating boilerplate security code.

This section covers writing custom instructions, handlers, and account structures in Anchor. Each instruction is a public function in the program module with its own handler in the 'instructions' folder. The handler must match the return type of the instruction function. The context structure defines which accounts the instruction will access. Module exports using 'pub use' in 'mod.rs' files make contents accessible to other parts of the program. Account structures define data stored on the blockchain and are defined in the 'state' folder. The 'account' macro enables serialization and deserialization. Each account structure must be exported using 'pub use' in a 'mod.rs' file. The 'account' macro validates that data at the address matches the expected type and provides compile-time validation of account access. Account structures typically include fields like 'slot' (block number) and 'name' (user-provided data). The 'account' macro enables Anchor to validate that the data at the address matches the expected type. Rust has two string types: 'String' (capital S) is heap-allocated and can change size, while 'str' (lowercase s) is a slice with fixed size. For smart contracts, 'String' is preferred because it can grow and shrink.

In Solana blockchain development, an instruction is a single function call to a deployed program that specifies on-chain operations, while a transaction is an atomic bundle of one or more signed instructions sent to the network for execution; when a sender transfers SOL, they create a transaction containing an instruction that invokes the system program to update account balances, and since all transactions are atomic, any failure in an instruction causes the entire transaction to revert and fail.

This section covers Solana client-side development. 1 billion lamports equal 1 SOL. Transaction instructions are individual operations within transactions. Wallet connection uses window.solana.connect(). PDAs can be derived on client side using program keys and seeds. Keypair generation creates public-private key pairs for signing. Transactions require recent block hashes to prevent replay attacks. sendRawTransaction() broadcasts transactions, while confirmTransaction() handles the full lifecycle. These concepts are essential for building Solana front-end applications.

Solana transactions contain arrays of signatures for permissioning, messages with metadata including signature counts and read-only address requirements, and arrays of instructions specifying program calls. Each instruction contains a program ID, account list, and byte-array parameters. The previous block hash enables proof-of-history consensus using time as a validation mechanism. Transactions exhibit atomic behavior where all instructions succeed or fail together. This structure ensures permissioned access, efficient validation, and data consistency across the network.

This comprehensive section covers the core concepts of Solana's programming model. Applications interact with Solana by sending transactions containing instructions to deployed programs. Programs are stateless Rust binaries deployed to validators, using an entry point for instruction dispatch. Transactions execute atomically - if any instruction fails, all changes revert. Accounts store all data on-chain as key-value pairs with unique 32-byte public keys. Programs must use accounts for persistent storage since they are stateless between invocations. Accounts have four key fields: data (binary array storing code or program data), executable flag, lamports (balance), and owner (program ID). Programs are stateless, so they store persistent data in data accounts owned by the program. Accounts require rent deposits in SOL - paying more than two years of rent makes accounts rent-exempt with refundable deposits. The system program handles fundamental operations like transfers, and only account owners can modify balances. The Solana Playground provides a web-based environment for learning development, allowing users to connect to DevNet, request airdrops, and run TypeScript code that creates transactions.

In Solana blockchain development, everything is stored in accounts that hold SOL (lumens) and optional data; to modify account state, developers create instructions specifying which program to call with particular arguments, bundle these instructions into transactions that include a fee payer and recent block hash, and sign them with private keys before sending to the network, where transactions are atomic meaning all instructions succeed or fail together, and every program is itself an account with executable code.