Stellar Development Skill (Soroban-first)

What this Skill is for

Use this Skill when the user asks for:

Soroban smart contract development (Rust)
Stellar dApp frontend work (React / Next.js / Node.js)
Wallet connection + signing flows (Freighter, etc.)
Transaction building / sending / confirmation
Stellar Asset issuance and management
Client SDK usage (JavaScript, Python, Go, Rust)
Zero-knowledge proof verification (where supported by target network/protocol)
Privacy-preserving applications (privacy pools, confidential tokens)
Local testing and deployment
Security hardening and audit-style reviews

What this Skill is NOT for

Bitcoin, Ethereum, Solana, or other non-Stellar blockchain development
Stellar node/validator operation (see validators docs)
General Rust programming unrelated to Soroban
Stellar protocol governance or CAP authoring

Default stack decisions (opinionated)

1. Smart Contracts: Soroban (Rust)

Use Soroban SDK (soroban-sdk crate) for all smart contract development
Contracts compile to WebAssembly (WASM)
Use #![no_std] - standard library not available
64KB contract size limit - use release optimizations
Prefer Stellar Assets over custom token contracts when possible

2. Client SDK: stellar-sdk (JavaScript) first

Use @stellar/stellar-sdk for browser and Node.js applications
Supports both Stellar RPC and legacy Horizon API
Full transaction building, signing, and submission
Soroban contract deployment and invocation

3. API Access: Stellar RPC first (Horizon legacy-focused)

Prefer Stellar RPC for new projects (JSON-RPC, real-time state)
Horizon API remains available for legacy compatibility and historical-query workflows
RPC: 7-day history for most methods; getLedgers queries back to genesis (Infinite Scroll)
Use Hubble/Galexie for comprehensive historical data beyond RPC

4. Token Strategy: Stellar Assets first

Prefer Stellar Assets (classic issuance + trustlines) for fungible tokens
Built-in ecosystem support (wallets, exchanges, anchors)
Stellar Asset Contracts (SAC) provide Soroban interoperability
Use custom Soroban tokens only for complex logic requirements

5. Testing

Local: Use Stellar Quickstart Docker for local network
Testnet: Use Testnet with Friendbot for funding
Unit tests: Compile to native for fast iteration
Integration tests: Deploy to local/testnet

6. Wallet Integration

Freighter is the primary browser wallet
Use Stellar Wallets Kit for multi-wallet support
Wallet Standard for consistent connection patterns

7. Freshness policy

Verify volatile facts (protocol support, RPC endpoints, CAP/SEP status, SDK API changes) against official docs before asserting them as current.

Operating procedure (how to execute tasks)

1. Classify the task layer

Smart contract layer (Soroban/Rust)
Client SDK/scripts layer (JS/Python/Go)
Frontend/wallet layer
Asset management layer (issuance, trustlines)
Testing/CI layer
Infrastructure (RPC/Horizon/indexing)

Quick routing

Need custom on-chain logic? → contracts-soroban.md
Building a frontend/dApp? → frontend-stellar-sdk.md
Issuing or managing tokens? → stellar-assets.md
Zero-knowledge proofs or privacy? → zk-proofs.md
Setting up tests/CI? → testing.md
Querying chain data or indexing? → api-rpc-horizon.md (also see Data Docs)
Security review? → security.md
Hit an error? → common-pitfalls.md
Need upgrade/factory/governance/DeFi architecture patterns? → advanced-patterns.md
Need SEP/CAP guidance and standards links? → standards-reference.md

2. Pick the right building blocks

Contracts: Soroban Rust SDK + Stellar CLI
Frontend: stellar-sdk (JS) + Freighter/Wallets Kit
Backend: stellar-sdk (JS/Python/Go) + RPC
Assets: Classic operations or SAC for Soroban interop
Testing: Quickstart (local) or Testnet

3. Implement with Stellar-specific correctness

Always be explicit about:

Network passphrase (Mainnet vs Testnet vs local)
Source account + sequence number
Fee + resource limits (for Soroban)
Authorization requirements
Trustline status for assets
Contract storage types (temporary vs persistent vs instance)

4. Add tests

Unit tests: Native compilation with #[test]
Integration tests: Local Quickstart or Testnet
Contract tests: Use Env from soroban-sdk
Frontend tests: Mock wallet/RPC interactions

5. Deliverables expectations

When you implement changes, provide:

Exact files changed + diffs
Commands to install/build/test/deploy
Network configuration (passphrase, RPC endpoint)
Risk notes for signing/fees/storage/authorization

Progressive disclosure (read when needed)

Smart contracts: contracts-soroban.md
Frontend + wallets: frontend-stellar-sdk.md
Testing strategy: testing.md
Stellar Assets: stellar-assets.md
Zero-knowledge proofs: zk-proofs.md
API access (RPC/Horizon): api-rpc-horizon.md
Security checklist: security.md
Common pitfalls: common-pitfalls.md
Advanced architecture patterns: advanced-patterns.md
SEP/CAP standards map: standards-reference.md
Ecosystem projects: ecosystem.md
Reference links: resources.md

Keywords

stellar, soroban, xlm, smart contracts, rust, wasm, webassembly, rpc, horizon, freighter, stellar-sdk, soroban-sdk, stellar-cli, trustline, anchor, sep, passkey, smart wallet, sac, stellar asset contract, defi, token, nft, scaffold stellar, constructor, upgrade, factory, governance, standards, zero-knowledge, zk, zk-snark, groth16, bn254, poseidon, pairing, privacy, confidential, noir, risc zero, privacy pool, merkle tree

stellar-dev