solana-foundation/anchor

Features

• Smart Contract Development Frameworks - A comprehensive framework for building, testing, and deploying Solana programs with automatic account validation and client generation.
• On-Chain Program Writing with DSL - Uses a Rust DSL with macros and account validation to define on-chain Solana smart contract logic.
• Blockchain Instruction Dispatchers - Maps annotated module functions to on-chain instructions with automatic account constraints and error handling.
• Contract Management - Provides a CLI toolchain for building, deploying, and managing Solana smart contracts across workspaces.
• On-Chain Account - Defines on-chain Solana account data structures using derive macros for automated serialization and deserialization.
• Account Constraint Validations - Checks account conditions at runtime to enforce business rules in Solana contracts.
• CLI Development Tools - Provides a command-line toolchain for scaffolding, building, deploying, and managing Solana smart contracts.
• Client Libraries - Provides generated client libraries for interacting with programs, sending instructions, and querying accounts.
• Client SDK Generators - Generates typed TypeScript and Rust client code from a contract interface to send instructions and fetch accounts.
• Contract Generation Interfaces - Automatically creates a standardized JSON file describing Solana smart contract instructions and accounts for client interaction.
• Debugging and Inspection Tools - Provides interactive debugging and inspection tools for Solana program development.
• Automated Test Execution - Automates building, deploying, and running tests with automatic blockchain lifecycle management.
• Instruction Handler Modules - Provides a macro to mark modules as instruction handler containers for Solana programs.
• Program Address Declarations - Ships a macro to declare a Solana program's on-chain address from a local keypair.
• Solana Development DSLs - Provides a Rust DSL with macros to define Solana instruction handlers, account structs, and errors.
• Account Validation Macros - Uses Rust derive macros to automatically validate account ownership and deserialization before instruction execution.
• CLI Workspaces - Provides a CLI workspace for bootstrapping, building, testing, and deploying Solana smart contracts.
• Workspace Configurations - Manages all contract IDs, provider URLs, and wallet paths through a single configuration file.
• Smart Contract Deployment Pipelines - Builds, deploys, upgrades, and verifies Solana smart contracts through a versioned command-line workflow.
• Smart Contract Compilers - Compiles Solana smart contract source code into deployable binary files for the target blockchain.
• Smart Contract Structuring with Macros - Uses macros to organize all account validation, instruction dispatch, and error handling in Solana smart contracts.
• Program Derived Address Derivations - Derives program-owned addresses deterministically for Solana account management.
• Program Derived Address Signers - Derives deterministic addresses from seeds and bump, enabling programs to sign cross-program invocations for owned accounts.
• Account Data Structure Definitions with Serialization - Defines the structure of data stored in custom Solana accounts with automatic owner, discriminator, and serialization.
• Account Owner Validations - Verifies account ownership against expected Solana program IDs before execution.
• Program Identifier Validations - Restricts instruction execution to accounts owned by designated Solana programs.
• Transaction Signer Verifications - Checks that required accounts signed the transaction in Solana smart contracts.
• Account Validation & Deserializers - Combines ownership checks and deserialization for Solana accounts automatically.
• Deterministic Address Calculation - Computes deterministic on-chain addresses for program-derived accounts in Solana smart contracts.
• Upgradeable Contract Deployment - Supports deploying new contract instances, upgrading existing ones, and verifying on-chain bytecode matches local builds.
• Test Harnesses - Ships a simulated environment for running Solana program instructions with account manipulation and compute unit benchmarking.
• Interface Definition Languages - Emits a standardized JSON interface from source code for typed client bindings and tooling.
• Contract Invocation Handlers - Calls instructions of other Solana programs from within a contract using sealed macros for composability.
• Account State Simulation - Runs local test suites with simulated accounts, time travel, and compute unit benchmarking.
• Integration Test Suites - Runs integration test suites with automatic local blockchain setup and state migration scripts.
• Test Environment Provisioning - Automates setup of local test nodes and simulation environments for Solana program testing.
• IDL-Based Client Generators - Generates Rust client modules from program interface definitions for instruction building and account fetching.
• Type-Safe Client Generators - Generates type-safe client code from smart contract interface definitions for TypeScript and Rust.
• Automated Contract Testing Suites - Automates the full contract test lifecycle: start blockchain, deploy, run tests, and stop.
• Type-Safe Clients - Creates typed clients from program interface definitions for type-safe instruction sending and account fetching.
• Blockchain Compilation and Key Sync - Compiles source into bytecode, generates interface files, expands macros, and synchronizes contract keys.
• Program Account Closures - Automates closure of program-owned accounts with rent refund and data cleanup in Solana.
• Type-Based Fetchers - Provides a client library that fetches and deserializes accounts by type with pagination and filtering.
• Cross-Contract Account Initializations - Enables account creation through cross-contract calls in Solana smart contracts.
• Idempotent Account Initializations - Supports conditional initialization of Solana accounts to avoid overwrites.
• Filtered Queries - Ships a client library that fetches and deserializes on-chain accounts with filtering and pagination.
• Account Mutability Declarations - Enables saving state changes to Solana accounts by declaring them mutable.
• Cross-Field Validators - Provides macros for cross-field key validation in account structs to enforce data consistency.
• Account Data Structures - Defines data structures that programs read and write directly from Solana account memory, avoiding serialization overhead.
• Mutable and Immutable Zero-Copy References - Provides both mutable and immutable zero-copy references for reading and modifying Solana account data directly from memory.
• Token Extensions - Adds optional state and behavior to token mints and accounts through configurable extensions.
• Mint Account Creations - Creates and initializes token mint accounts using generated keypairs or deterministic addresses.
• Minting Mechanisms - Mints new tokens by invoking a token contract, increasing the total on-chain token supply.
• Rust-to-JavaScript Mappings - Maps Rust program types to JavaScript equivalents for type-safe client-program communication.
• Zero-Copy Deserialization - Reads and writes Solana account data directly from serialized bytes using Pod structs, avoiding heap allocation.
• Byte-Level Account Data Access - Provides zero-copy access to large Solana account data structures, avoiding deserialization overhead and heap allocations.
• IDL-Based Instances - Creates typed program instances from interface definitions for sending instructions and fetching accounts.
• Contract Artifact Generators - Compiles source programs, expands macros, and manages metadata for deployment to a test network.
• Built-in Solana Account Accessors - Provides automatic access to Solana’s built-in system accounts in instruction handlers.
• Contract Deployment Scripts - Builds contract source and deploys to a local development blockchain, updating the on-chain address.
• Contract Verification Tools - Compares local build and interface description against deployed contracts to confirm reproducibility.
• Interface Definition Language Generators - Emits a standardized JSON interface description from Solana program source code for client tooling.
• Custom Constraint Evaluations - Enables custom boolean constraint evaluation for account validation in Solana programs.
• Executable Account Checks - Provides a macro to verify that an account is executable, confirming it is a smart contract.
• Interface-Based Invocations - Builds and sends blockchain instructions using typed methods derived from program interface definitions.
• Typed Method Builders - Builds, signs, and sends blockchain instructions using typed method builders from program interface definitions.
• IDL-Based Address Resolutions - Generates client-friendly account addresses from Solana program interface descriptions.
• Seeded Address Validations - Validates deterministic PDA addresses using seeds and bump in Solana instructions.
• Cross-Contract Token Transfers - Transfers tokens between accounts by invoking a token contract using cross-contract calls.
• Program Account Removals - Ships utilities to remove deployed contracts and recover their rent allocation on Solana.
• SPL Token Account Management - Ships utilities for creating and validating SPL token accounts, mint accounts, and associated token accounts.
• Token Account Creations - Create and initialize token accounts, including associated and derived accounts, to hold token balances.
• Reproducible Build Environments - Builds contracts inside a pinned, deterministic environment to produce bytecode verifiable against source.
• Reproducible Builds - Produces deterministic builds so deployed contracts can be verified against published source code.
• Token Contract Interactions - Simplifies interaction with token contracts and extensions from within a smart contract.
• Compute Usage Metrics - Measures and records compute unit consumption of program instructions for benchmarking.
• Client-Side Contract Test Scripts - Executes client-side test scripts that invoke contract instructions for validation.
• Direct Account Data Injections - Enables direct writing of account data in tests to bypass constraints and test edge cases.
• Instruction Chain Testing - Enables sequential instruction chain testing with per-instruction validation in Solana programs.
• Live Account Imports - Imports accounts from a live network into the test environment for realistic simulation.
• Multi-Language Test Frameworks - Supports writing and running program logic tests in multiple programming languages.
• Pre-Compiled Program Deployments - Deploys pre-compiled programs into test environments for instruction simulation.
• Single Instruction Simulators - Simulates and validates single program instructions in a lightweight environment.
• Time Simulation Utilities - Overwrites the system clock or advances time to test time-dependent logic in Solana programs.
• Cross-Program Module Generators - Generates modules from program interfaces to enable cross-program calls without third-party dependencies.
• Blockchain Infrastructure - Development framework for building secure Solana programs.
• Frameworks and Libraries - Primary framework for developing secure Solana programs.

Star history