Access your supported Stellar environment and interact with compatible functionality.
Stellar browser wallet
Stellar connection protocol
Stellar wallet
Network: —
Soroban is the smart contract platform within the Stellar ecosystem. It provides developers with the ability to write contracts in Rust, compile them to WebAssembly, and deploy them to the Stellar network where they can execute deterministically and manage application state on the ledger.
Smart contracts enable programmable logic to exist directly on a blockchain network. They allow developers to create applications that execute without intermediaries, manage digital assets, enforce agreements, and build financial infrastructure that operates transparently and verifiably.
A Soroban contract is written in Rust and compiled to WebAssembly. When invoked through a transaction, the Soroban runtime loads the contract's WASM bytecode, provides it with access to the host environment, and executes its functions. The contract can read and write state, emit events, and return results.
Contract state is stored as ledger entries on the Stellar network. Each contract has its own storage namespace. State changes occur during contract execution and are committed as part of the transaction result. The ledger provides persistent, verifiable storage for application data.
A Stellar transaction can include Soroban operations that invoke contract functions. The transaction specifies the contract address, function name, and arguments. The network validates, sequences, and executes the transaction, producing a result that reflects the contract's computation.
Applications interact with Soroban contracts through SDKs that construct transactions, submit them to the network, and parse results. The Soroban SDK provides tools for both writing contracts and building client applications that invoke them.
Every Soroban contract is a Rust crate that compiles to WASM. The contract defines functions that can be invoked externally, along with internal helper logic and type definitions.
Contract functions are marked with attributes that make them callable. They accept typed parameters and return typed values. The host environment provides access to storage, events, and authorization context.
Contracts can persist data across invocations using the storage API. Data is organized into instance storage (specific to the contract) and temporary storage (with configurable expiration).
Soroban provides an authorization framework that allows contracts to verify the identity of callers and manage access control. Invocations can require signatures from specific accounts.
Contracts emit events to communicate what happened during execution. Events are recorded on the ledger and can be observed by off-chain systems monitoring contract activity.
Contracts define error types that communicate failure conditions. When a contract encounters an error during execution, the transaction fails and the error is returned to the caller.
Soroban provides a testing environment that simulates the host runtime. Developers can write unit tests and integration tests that exercise contract logic without deploying to a network.
Contracts are deployed by uploading their WASM bytecode to the network and then creating a contract instance from that code. The instance receives a unique contract address.
Once deployed, contracts are invoked by constructing transactions that call specific functions with specific arguments. The network executes the call and returns the result.
Rust provides memory safety without garbage collection, strong type systems, and excellent tooling. These characteristics make it well-suited for writing smart contracts where correctness, performance, and security are critical. Rust's compile-time checks help catch errors before contracts are deployed.
Developers use the Soroban SDK for Rust to write contracts. The SDK provides macros, types, and APIs that integrate with the Soroban host environment. The development workflow includes writing contract logic, defining types, and specifying storage patterns.
The Soroban SDK includes a testing framework that provides a simulated host environment. Developers can create test contexts, deploy contracts, invoke functions, and assert on results and state changes.
Contracts are compiled to WASM using the Soroban CLI tools. The resulting WASM binary is uploaded to the network, and a contract instance is created. The CLI handles building, optimizing, and deploying contracts.
The Soroban CLI provides commands for building contracts, deploying them, invoking functions, and managing test environments. The SDK integrates with standard Rust development tools including cargo.
A client application constructs a transaction containing a Soroban invocation operation and submits it to a Stellar node.
The network validates the transaction structure, signatures, fees, and sequence numbers before including it in a transaction set.
The Soroban runtime verifies that the invocation has proper authorization from the required parties.
The contract's WASM code is loaded and the specified function is executed with the provided arguments within the host environment.
Any state changes made during execution are collected and prepared for commitment to the ledger.
The transaction result, including return values, events, and state changes, is committed to the ledger as part of the consensus process.
Soroban provides an authorization framework for managing who can invoke contract functions and under what conditions.
Contracts implement access control logic to restrict operations to authorized callers and enforce permission boundaries.
Rust's type system and ownership model help prevent common classes of bugs. Additional testing and auditing practices further reduce risk.
Comprehensive testing using the Soroban test framework helps verify contract behavior before deployment.
Independent security audits provide additional assurance. Auditors review contract logic for vulnerabilities and edge cases.
Contracts may include upgrade mechanisms. The design of upgrade paths affects the security properties of the system.
Understanding how contracts can fail — reverts, panics, unexpected inputs — is essential for building robust systems.
Managing keys, deployment processes, and monitoring contract activity are ongoing operational responsibilities.
Security is a shared responsibility. Platform providers, developers, and users all play roles in maintaining system integrity.
A contract that manages a fungible token with transfer, balance, and allowance functionality on the Stellar network.
A contract that facilitates conditional payments, escrow arrangements, and multi-party settlement logic.
A contract that enables listing, bidding, and exchange of digital assets between participants.
A contract that holds assets under defined conditions and releases them when agreed-upon criteria are met.
A contract that manages recurring access rights and payment schedules for service-based applications.
A contract that enables proposal creation, voting mechanisms, and collective decision-making processes.
A contract that manages verifiable credentials, identity attestations, and access control based on identity proofs.
A contract that manages portfolios, allocation rules, and asset lifecycle operations for digital assets.
A contract that implements decentralized financial primitives such as lending, borrowing, or exchange logic.
A contract that manages game state, player assets, scoring systems, and on-chain game mechanics.
Stellar is a decentralized network designed for fast, low-cost financial transactions. Soroban extends this network with smart contract capabilities, enabling developers to build programmable applications that leverage Stellar's infrastructure.
Soroban smart contracts are programs that execute on the Stellar network. They are written in Rust, compiled to WebAssembly, and operate within a deterministic runtime environment that manages state and enforces execution rules.
Stellar's native asset model supports a wide range of token types. Soroban contracts can interact with these assets, enabling new forms of programmable asset management and financial logic.
The Stellar network's payment infrastructure provides the foundation for value transfer. Soroban contracts can build upon this infrastructure to create sophisticated payment flows and financial applications.
Developers can build full-stack applications that use Soroban contracts for on-chain logic and off-chain systems for user interfaces, data indexing, and auxiliary services.
The Stellar network provides consensus, transaction ordering, and ledger storage. Soroban operates within this infrastructure, using the network's security and performance characteristics.
An environment for writing, editing, and iterating on Soroban smart contracts. The studio provides tools for managing contract source code, dependencies, and project structure using standard Rust development practices.
A comprehensive testing environment where developers can write unit tests, integration tests, and scenario-based tests for their contracts. The testing framework simulates the Soroban host environment for accurate test execution.
Tools and processes for deploying compiled contracts to the Stellar network. This includes building WASM binaries, uploading code to the network, and creating contract instances with proper initialization.
Comprehensive technical documentation covering all aspects of Soroban development — from getting started guides to advanced architecture patterns, API references, and best practices.
The Soroban SDK provides Rust libraries for contract development and JavaScript/TypeScript SDKs for building client applications. These tools abstract the complexity of transaction construction and contract interaction.
Resources and tools for understanding contract security — including common vulnerability patterns, testing methodologies, audit preparation guides, and operational security practices.
Community resources including forums, discussion channels, example repositories, and collaboration spaces where developers can learn from each other and contribute to the ecosystem.
Soroban is built in the open. The source code, specifications, and development discussions are publicly available. Developers can study the implementation, contribute improvements, and build upon the foundation.
Understand the foundational concepts of blockchain technology — distributed ledgers, consensus mechanisms, transaction models, and cryptographic primitives. This level establishes the vocabulary and mental models needed to understand smart contract platforms.
Learn what smart contracts are, how they differ from traditional software, and why they matter. Explore the concept of programmable logic on a blockchain, the execution model, and the relationship between contracts and the networks that run them.
Introduction to Soroban specifically — its role within the Stellar ecosystem, its architecture, its execution model, and how it enables developers to build programmable applications on Stellar.
Learn the Rust programming language as it applies to Soroban contract development. Cover ownership, borrowing, types, traits, and the no_std environment that Soroban contracts operate within.
Study patterns for structuring Soroban contracts — module organization, type design, storage strategies, authorization patterns, and how to build contracts that are maintainable and composable.
Master the Soroban testing framework. Learn to write effective unit tests, integration tests, and property-based tests. Understand how to simulate the host environment and verify contract behavior.
Study contract security from multiple angles — common vulnerability patterns, authorization design, input validation, reentrancy considerations, and the operational practices that keep contracts safe.
Learn the complete deployment workflow — building optimized WASM binaries, uploading to testnet and mainnet, creating contract instances, and managing the deployment lifecycle.
Build full applications around Soroban contracts. Learn about client SDKs, transaction construction, event indexing, off-chain services, and how to design systems that integrate on-chain and off-chain components.
Explore cutting-edge topics in smart contract research — novel authorization schemes, cross-contract composition patterns, performance optimization, and emerging application paradigms on Stellar.
Setup and first contract
Core mental models
System design overview
Writing contracts
Rust for Soroban
Rust and JS SDKs
Host function reference
Command-line tools
Test frameworks
Deploy workflows
Security practices
Reference contracts
Step-by-step guides
Common issues
Complete reference
Stellar network status
Deployed contracts
Transaction history
Contract events
Account information
Asset details
Ledger information
Investigating the Soroban runtime environment — how WASM execution works, how the host environment provides capabilities to contracts, and how execution boundaries are enforced.
Studying contract patterns, composability models, cross-contract communication, and the design space of programmable applications on Stellar.
Exploring how to make Soroban development more accessible — better tooling, clearer documentation, improved error messages, and streamlined workflows.
Analyzing contract execution performance, WASM optimization techniques, storage access patterns, and throughput characteristics of the Soroban runtime.
Investigating contract vulnerability patterns, authorization model analysis, formal verification approaches, and threat modeling for Soroban applications.
Studying how to design applications that effectively use Soroban contracts — architecture patterns, data flow, event systems, and integration strategies.
Exploring how developers and users might interact with smart contract systems in the future — new paradigms for contract interaction, visualization, and debugging.
Programmable payment flows, conditional transfers, and multi-party settlement systems.
Decentralized financial primitives including lending, borrowing, and exchange logic.
On-chain game state, digital asset ownership, scoring systems, and game mechanics.
Decentralized exchange, listing, bidding, and trade settlement infrastructure.
Representing real-world and digital assets as programmable tokens on the ledger.
Verifiable credentials, decentralized identity, and attestation systems.
Foundational contracts that other applications build upon — oracles, bridges, registries.
Collective decision-making, proposal systems, voting mechanisms, and treasury management.
On-chain data verification, timestamping, and provenance tracking systems.
Scheduled execution, conditional triggers, and autonomous contract behavior.
Early blockchains provided immutable ledgers for recording transactions. The blockchain was a ledger — it could record transfers but could not execute arbitrary logic. Applications were limited to the operations the protocol natively supported.
The introduction of smart contracts transformed blockchains from static ledgers into programmable platforms. Developers could write logic that executed on the network, enabling applications beyond simple value transfer.
As smart contract platforms matured, developers began building full applications — decentralized exchanges, lending protocols, governance systems, games, and more. The ecosystem of on-chain applications expanded rapidly.
Soroban brings smart contract functionality to the Stellar ecosystem. Built on Rust and WebAssembly, it provides developers with a modern, secure environment for building programmable applications on Stellar's network infrastructure. [VERIFIED SOROBAN SPECIFICATION REQUIRED for specific dates]
Applications that implement financial logic — payments, settlements, escrows, and treasury management — as on-chain programs.
Contracts that encode agreement logic and execute automatically when conditions are met, reducing the need for intermediaries.
Systems that represent assets, rights, or obligations as programmable tokens that can be managed by smart contracts.
Applications where core logic executes on-chain, providing transparency, verifiability, and resistance to censorship.
Marketplaces where trade rules, escrow, and settlement are managed by contracts rather than centralized operators.
Payment flows that include conditional logic, multi-party splits, scheduling, and complex routing rules.
Application state and business logic that lives on the blockchain, accessible and verifiable by any participant.
The smart contract platform within the Stellar ecosystem, enabling developers to build programmable applications.
Programs that execute on a blockchain network, managing state and implementing application logic.
The programming language used to write Soroban contracts, providing memory safety and strong typing.
The binary format that Soroban contracts compile to, enabling portable and efficient execution.
The decentralized network that Soroban operates within, providing consensus and ledger infrastructure.
The framework Soroban uses to manage caller permissions and verify identities during contract invocation.
Records emitted by contracts during execution that describe what occurred and can be observed externally.
The persistent data management system that contracts use to maintain state across invocations.