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