Solana Program Derived Addresses (PDA): Derivation Explained

Solana and Cardano use the Ed25519 curve, which has the equation -x² - y² = 1 + dx²y², with d = -121665/121666. This curve is defined over a finite field with p = 2²⁵⁵ - 19. Ed25519 is faster than secp256k1 because: (1) the curve equation is simpler (no cubic term), (2) the field is smaller, (3) the curve has no small subgroup attacks. These advantages make Ed25519 suitable for high-performance blockchains like Solana. The public key is derived by multiplying the private key with the generator point G, then hashing with SHA-512 and taking the first 32 bytes. The address is then encoded using Base58, similar to Bitcoin but with a different prefix (4S for Solana).

Solana addresses (public keys) land on an elliptic curve, where each point corresponds to a public key derived from a private scalar. Regular key pairs always land on this curve. Program Derived Addresses intentionally derive addresses that fall off the curve, ensuring they have no corresponding private key. This cryptographic distinction is fundamental to understanding why PDAs are secure despite appearing to be regular addresses.

Asymmetric cryptography uses public and private key pairs for secure communication over unsecured channels. In elliptic curve cryptography, Alice has a private key and computes her public key as B × G. Bob has his own private key and computes A × G. The shared secret is A × B × G, which both parties can derive independently. This enables secure key exchange without prior communication. The curve Ed25519 (Twisted Edwards curve) is used in Monero, defined over the field 2^255 - 19.

In asymmetric cryptography, there are two types of keys: (1) Public key - shared with everyone who wants to communicate securely; (2) Private key - kept exclusively by the owner and never shared. The public key is used to encrypt messages, while the private key decrypts them. This separation ensures that only the intended recipient (with the private key) can read encrypted communications, even if the public key is widely distributed.

Asymmetric cryptography uses paired public and private keys for secure communication. In elliptic curve cryptography, each user has a private key (random integer) and a public key calculated as private_key × G, where G is a known base point. When two parties establish a shared secret, each computes the other's public key multiplied by their own private key, resulting in the same value (private_key_A × private_key_B × G). This allows secure key exchange over insecure channels without prior communication.

Programs are executable accounts storing code, while state resides in separate accounts. Transactions bundle instructions (function calls to programs) and must declare all modified accounts for parallel execution. Cross-program invocation (CPI) allows programs to call other programs, carrying over signed account permissions. The maximum CPI depth is currently four levels. When a program calls another, it sends instructions and receives signed accounts, enabling complex multi-program interactions like initializing state through system program calls.

This comprehensive section covers the complete process of learning to interact with Solana programs without source code. The process begins with investigating existing transactions to understand program structure, using transaction simulation to identify program addresses, and examining instruction data to understand required accounts and parameters. Key technical skills include building transaction messages with fee payers and lifetimes, appending instructions with program addresses and accounts, understanding account roles (writable, signer, read-only), decoding instruction data from base64, and understanding Associated Token Accounts (ATAs) and their derivation. The section emphasizes that understanding transaction structure is essential before attempting to call any program programmatically, and that simulation is critical for debugging before execution.

This section covers Solana program (smart contract) structure and execution. Programs are written in Rust with an entry point receiving program ID, account list, and byte-array instruction data. Logging uses msg! macros instead of print statements. Programs iterate over AccountInfo arrays to access specific accounts in required order. Critical owner verification ensures only the owning program can modify accounts. Borscht library enables serialization/deserialization between binary formats and Rust structs. Cross-program invocation allows modular application architecture by enabling programs to call each other, supporting reusable components and third-party functionality integration. The sample hello world program demonstrates basic mechanics including owner checks, data incrementing, and logging.

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.

Solana programs are compiled to eBPF bytecode and execute on the Solana virtual machine, receiving a consistent structure of program ID, accounts array, and data buffer for each invocation. Unlike Ethereum's free read-only queries, Solana charges for all transactions including reads, requiring funded wallets. Programs must handle instruction data by parsing the first byte as an instruction key and deserializing remaining data, typically using little-endian encoding. The development workflow involves creating Rust libraries, compiling with cargo build bpf, deploying via the CLI, and interacting through web3.js with connections and signers.

A cryptographic hashing function is a mathematical algorithm that takes an input (or 'message') and returns a fixed-size string of characters, which serves as a unique identifier or 'fingerprint' for that input; this process is deterministic (same input always produces same output), produces fixed-size outputs regardless of input length, is computationally efficient, cannot be reversed to reveal the original input, and is designed to make it practically impossible to find two different inputs that produce the same output (collision resistance), with SHA-256 being a widely used example in cryptocurrencies like Bitcoin for implementing proof-of-work mining.

A cryptographic hash function takes any input (message or file) and produces a fixed-length string of bits called a hash or digest. The output appears random but is deterministic—given the same input, the same hash is always produced. Critically, even a tiny change to the input causes the hash to change completely in unpredictable ways. For cryptographic security, it must be infeasible to compute the reverse: given a hash output, finding an input that produces it requires no better method than random guessing. SHA256 is a widely-used cryptographic hash function with 256-bit outputs.

Cryptographic hash functions map arbitrary-length strings to fixed-length outputs (160-256 bits) with three core properties: determinism (same input yields same output), public computability (anyone can compute the hash), and apparent randomness (output looks random). Unlike simple hash functions like K mod P used in dictionaries, cryptographic hash functions require much stronger security guarantees. Historical examples include MD4 (1992, broken), MD5 (128-bit, now broken), SHA-1 (160-bit, considered broken), and SHA-3 (current standard). These functions undergo extensive analysis and are designed to be computationally expensive (100+ rounds) to prevent attacks.

Hash functions are deterministic, meaning the same input always produces the same output. If you hash the same password twice, you will get the exact same hash each time. This property is essential for authentication systems to verify user credentials.

SQRL uses HMAC with a user's master identity as the key to deterministically derive unique private keys for each website visited. When a user visits a domain like www.amazon.com, the domain name is hashed through the HMAC function using the master key to produce a fixed-size blob. This blob serves as the private key for that specific site. Because the same domain name always produces the same hash output with the same key, users receive the same private key every time they return to the same site. However, since every user has a different master identity, two users visiting the same site will generate completely different private keys.