Solana Starter Program

A comprehensive full-stack Solana development starter kit featuring Anchor programs, a modern Next.js frontend, and a Go-based event indexer. Demonstrates all essential Solana patterns including PDAs, SPL tokens, cross-program invocations, RBAC, real-time blockchain data fetching, and event indexing.

Overview

This monorepo contains three main components:

starter_program/ - Anchor workspace with two Solana programs (39+ integration tests)
frontend/ - Next.js 16.1.1 frontend with full Solana integration and program interaction
go_indexer/ - High-performance event indexer with MongoDB/PostgreSQL support

Features

Anchor Programs

Feature	Description
Program Configuration	Admin-controlled config with pause functionality
PDA Patterns	User accounts with seeds-based derivation
SPL Token Operations	Mint, transfer, and burn tokens
Cross-Program Invocation	CPI examples with and without PDA signers
Inter-Program Communication	Counter program with bidirectional CPI patterns
Role-Based Access Control	Permission system with role assignment
Error Handling	Custom error codes with descriptive messages

Frontend

Feature	Description
Next.js 16.1.1	App Router with React 19
Wallet Integration	Phantom, Solflare, Torus, Backpack support
Real-time Updates	WebSocket subscriptions for balance changes
Program Interaction	Full integration with both Starter and Counter programs
TypeScript Strict	Type-safe development with auto-generated Anchor types
Tailwind CSS 4	Modern styling with custom components
Custom Hooks	Reusable hooks for Solana interactions
SWR Integration	Optimized data fetching and caching

Go Indexer

Feature	Description
Multi-Program Support	Indexes both Starter (Anchor) and Counter (log-based) programs
Dual Decoding	Anchor discriminator-based + regex log parsing
Real-time Processing	Polls RPC and processes events immediately
Database Support	MongoDB (primary) and PostgreSQL (stub)
Concurrent Processing	Configurable batch size and concurrency
Production Ready	Graceful shutdown, error handling, logging
Event Types	26+ event types indexed (20 Starter + 6 Counter)

Quick Start

Prerequisites

For Programs:

Rust 1.70+
Solana CLI 1.18+
Anchor CLI 0.31.1

For Frontend:

Node.js 18+
pnpm (recommended)

For Indexer:

Go 1.24+
MongoDB 4.4+ or PostgreSQL 12+

1. Install Anchor

cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
avm install 0.31.1
avm use 0.31.1

2. Build & Test Programs

cd starter_program
yarn install
anchor build
anchor test

3. Run Frontend

cd frontend
pnpm install
cp .env.local.example .env.local
pnpm dev

Open http://localhost:3000

4. Run Indexer (Optional)

cd go_indexer
cp .env.example .env
# Edit .env with your program IDs
docker-compose up -d mongodb
go run cmd/indexer/main.go

View indexed events:

mongosh solana_indexer
db.events.find().sort({block_time: -1}).limit(10).pretty()

Project Structure

solana-starter-program/
├── starter_program/                 # Anchor workspace
│   ├── programs/
│   │   ├── starter_program/        # Main program (17 instructions)
│   │   │   └── src/
│   │   │       ├── lib.rs
│   │   │       ├── constants.rs
│   │   │       ├── error.rs
│   │   │       ├── state/          # Config, User, Role accounts
│   │   │       └── instructions/   # All instruction handlers
│   │   └── counter_program/        # Counter program (6 instructions)
│   ├── tests/
│   │   ├── starter_program.ts      # 25+ tests
│   │   ├── cross_program.ts        # 11 tests
│   │   └── rbac.ts                 # RBAC tests
│   ├── Anchor.toml
│   └── CROSS_PROGRAM.md            # CPI guide
│
├── frontend/                        # Next.js 16.1.1 application
│   ├── app/                         # App Router pages
│   │   ├── dashboard/              # Main dashboard
│   │   ├── programs/               # Program interactions
│   │   └── layout.tsx              # Root layout
│   ├── components/
│   │   ├── features/
│   │   │   ├── wallet/             # Wallet components
│   │   │   ├── starter/            # Starter program features
│   │   │   │   ├── token-operations.tsx
│   │   │   │   ├── user-account.tsx
│   │   │   │   ├── governance.tsx
│   │   │   │   ├── role-management.tsx
│   │   │   │   ├── treasury-management.tsx
│   │   │   │   ├── nft-collection.tsx
│   │   │   │   ├── nft-marketplace.tsx
│   │   │   │   └── cross-program-demo.tsx
│   │   │   └── counter/            # Counter program UI
│   │   │       └── counter-display.tsx
│   │   └── ui/                     # Reusable components
│   └── lib/
│       ├── hooks/                  # Custom React hooks (13 hooks)
│       │   ├── use-starter-program.ts
│       │   ├── use-counter-program.ts
│       │   ├── use-token-operations.ts
│       │   ├── use-governance.ts
│       │   ├── use-role-management.ts
│       │   ├── use-treasury.ts
│       │   ├── use-nft-collection.ts
│       │   ├── use-nft-marketplace.ts
│       │   └── ... (and more)
│       ├── anchor/                 # Program IDLs and types
│       │   ├── idl/               # JSON IDL files
│       │   ├── types/             # TypeScript types
│       │   └── program.ts         # Program instances
│       └── solana/                # Connection config
│
└── go_indexer/                     # Event indexer
    ├── cmd/
    │   └── indexer/               # Main entry point
    ├── internal/
    │   ├── config/                # Configuration
    │   ├── decoder/               # Event decoders
    │   │   ├── anchor_decoder.go  # Anchor events
    │   │   └── counter_parser.go  # Log parser
    │   ├── indexer/               # Core logic
    │   ├── models/                # Event models
    │   ├── processor/             # Event processor
    │   └── repository/            # Database layer
    │       ├── mongo.go           # MongoDB (primary)
    │       └── postgres.go        # PostgreSQL (stub)
    ├── pkg/
    │   └── solana/               # RPC client
    └── docs/                     # Documentation

Programs

Starter Program

Program ID: gARh1g6reuvsAHB7DXqiuYzzyiJeoiJmtmCpV8Y5uWC

Instruction	Description
`initialize`	Initialize program
`initialize_config`	Create program config
`update_config`	Update admin, fees
`toggle_pause`	Pause/unpause program
`create_user_account`	Create PDA user account
`update_user_account`	Update user points
`close_user_account`	Close and reclaim rent
`create_mint`	Create SPL token mint
`mint_tokens`	Mint tokens
`transfer_tokens`	Transfer tokens
`burn_tokens`	Burn tokens
`transfer_sol`	Transfer SOL via CPI
`transfer_sol_with_pda`	Transfer SOL from PDA
`transfer_tokens_with_pda`	Transfer tokens from PDA
`assign_role`	Assign role to user
`update_role_permissions`	Modify role permissions
`revoke_role`	Remove role from user

Counter Program

Program ID: CounzVsCGF4VzNkAwePKC9mXr6YWiFYF4kLW6YdV8Cc

Instruction	Description
`initialize`	Create counter account
`increment`	Increment by 1
`decrement`	Decrement by 1
`add`	Add arbitrary value
`reset`	Reset to 0 (authority only)
`increment_with_payment`	Increment with SOL payment (CPI demo)

Usage Examples

Initialize Config

const [configPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('program_config')],
  program.programId
);

await program.methods
  .initializeConfig(feeDestination)
  .accounts({
    programConfig: configPda,
    authority: admin.publicKey,
    systemProgram: SystemProgram.programId,
  })
  .rpc();

Create User Account (PDA)

const [userPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('user_account'), user.publicKey.toBuffer()],
  program.programId
);

await program.methods
  .createUserAccount()
  .accounts({
    userAccount: userPda,
    authority: user.publicKey,
    systemProgram: SystemProgram.programId,
  })
  .rpc();

Cross-Program Invocation

// Increment counter via CPI from starter_program
await program.methods
  .incrementCounter()
  .accounts({
    counter: counterPda,
    authority: user.publicKey,
    counterProgram: counterProgram.programId,
  })
  .rpc();

Mint Tokens

const userTokenAccount = await getAssociatedTokenAddress(
  mintPda,
  user.publicKey
);

await program.methods
  .mintTokens(new BN(1000000))
  .accounts({
    signer: user.publicKey,
    tokenAccount: userTokenAccount,
    mint: mintPda,
    mintAuthority: mintAuthority,
    tokenProgram: TOKEN_PROGRAM_ID,
    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
    systemProgram: SystemProgram.programId,
  })
  .rpc();

Frontend Hooks

The frontend provides 13 custom hooks for Solana interactions:

// Wallet hooks
const { balance, isLoading } = useBalance(publicKey, { refreshInterval: 30000 });
const { account, isLoading } = useAccount(publicKey);
const { send, loading, error } = useSendTransaction({ onSuccess, onError });

// Starter Program hooks
const { createUserAccount, updateUserAccount } = useStarterProgram();
const { mintTokens, transferTokens, burnTokens } = useTokenOperations();
const { propose, vote, execute } = useGovernance();
const { assignRole, revokeRole, updatePermissions } = useRoleManagement();
const { deposit, withdraw, distribute } = useTreasury();
const { createCollection, mintNft } = useNftCollection();
const { listNft, buyNft, cancelListing } = useNftMarketplace();

// Counter Program hooks
const { initialize, increment, decrement, add, reset } = useCounterProgram();

// Transaction history
const { transactions, isLoading } = useTransactionHistory(publicKey, { limit: 10 });

Go Indexer Features

Event Indexing

# Monitor both programs simultaneously
2026/01/08 15:30:45 starting indexer for Starter Program gARh1g6reuvsAHB7...
2026/01/08 15:30:45 starting indexer for Counter Program CounzVsCGF4VzNk...
2026/01/08 15:30:51 processed starter event TokensMintedEvent at slot 123456
2026/01/08 15:30:52 processed counter event CounterIncrementedEvent at slot 123457

Query Examples

MongoDB:

// All token mint events
db.events.find({ event_type: "TokensMintedEvent" })

// Counter value progression
db.events.find({ 
  event_type: /Counter(Incremented|Decremented|Added)/,
  counter: "COUNTER_PUBKEY" 
}).sort({ block_time: 1 })

// High-value NFT sales
db.events.find({ 
  event_type: "NftSoldEvent",
  price: { $gte: 1000000000 }
}).sort({ price: -1 })

PostgreSQL:

-- Events by type
SELECT event_type, COUNT(*) 
FROM events 
GROUP BY event_type;

-- Recent Counter payments
SELECT * FROM events
WHERE event_type = 'CounterPaymentReceivedEvent'
ORDER BY block_time DESC
LIMIT 10;

Testing

cd starter_program

# Run all tests
anchor test

# Run specific test file
anchor test tests/starter_program.ts
anchor test tests/cross_program.ts
anchor test tests/rbac.ts

Test Coverage: 39+ integration tests covering all program functionality.

Network Configuration

Programs (Anchor.toml)

[provider]
cluster = "localnet"  # Change to devnet/mainnet
wallet = "~/.config/solana/id.json"

Frontend (.env.local)

NEXT_PUBLIC_SOLANA_RPC_HOST=https://api.devnet.solana.com
NEXT_PUBLIC_SOLANA_NETWORK=devnet

Security Features

Account ownership validation
Seeds validation for PDAs
Bump seed storage and verification
has_one constraints for authority checks
Rent exemption enforcement
Custom error codes with descriptive messages
Role-based access control system

Component Documentation

Each component has detailed documentation:

Programs: See starter_program/README.md
- Anchor program architecture
- Instruction reference
- Testing guide
- Cross-program invocation patterns
Frontend: See frontend/README.md
- Component structure
- Custom hooks API
- Wallet integration
- Real-time updates
Indexer: See go_indexer/README.md
- Event indexing architecture
- MongoDB/PostgreSQL setup
- Query examples
- Deployment guide

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                     Solana Blockchain                        │
│  ┌─────────────────┐           ┌─────────────────┐         │
│  │ Starter Program │           │ Counter Program │         │
│  │  (17 instr.)    │◄─────CPI──┤  (6 instr.)    │         │
│  └────────┬────────┘           └────────┬────────┘         │
│           │                             │                   │
└───────────┼─────────────────────────────┼───────────────────┘
            │                             │
            │                             │
    ┌───────▼─────────────────────────────▼───────┐
    │            RPC Endpoint                       │
    └───────┬─────────────────────────┬────────────┘
            │                         │
            │                         │
    ┌───────▼──────────┐      ┌──────▼──────────┐
    │   Next.js        │      │  Go Indexer     │
    │   Frontend       │      │                 │
    │                  │      │  ┌───────────┐  │
    │  • Wallet UI     │      │  │  MongoDB  │  │
    │  • Token Ops     │      │  │   Events  │  │
    │  • NFT Market    │      │  └───────────┘  │
    │  • Governance    │      │                 │
    │  • Role Mgmt     │      │  ┌───────────┐  │
    │  • Treasury      │      │  │PostgreSQL │  │
    │  • Counter UI    │      │  │  (optional)│  │
    └──────────────────┘      │  └───────────┘  │
                              └─────────────────┘

Key Features Highlight

1. Complete Solana Program Suite

✅ Token operations (mint, transfer, burn)
✅ User account management (PDA-based)
✅ Role-based access control (RBAC)
✅ Governance system (proposal voting)
✅ Treasury management (multi-sig)
✅ NFT collection & marketplace
✅ Cross-program invocations
✅ Counter with payment integration

2. Production-Ready Frontend

✅ 13 custom hooks for all program interactions
✅ Multi-wallet support (Phantom, Solflare, Backpack, Torus)
✅ Real-time balance updates via WebSocket
✅ SWR for optimized data fetching
✅ Responsive UI with Tailwind CSS
✅ TypeScript strict mode
✅ Auto-generated Anchor types

3. Scalable Event Indexer

✅ Multi-program support (Starter + Counter)
✅ Dual decoding (Anchor events + log parsing)
✅ Real-time event processing
✅ MongoDB primary with PostgreSQL support
✅ 26+ event types indexed
✅ Production-ready with Docker
✅ Comprehensive query examples

Testing

Program Tests

cd starter_program
anchor test                          # All tests (39+)
anchor test tests/starter_program.ts # Starter only
anchor test tests/cross_program.ts   # CPI tests
anchor test tests/rbac.ts           # RBAC tests

Frontend Development

cd frontend
pnpm dev                            # Development server
pnpm build                          # Production build
pnpm lint                           # Linting

Indexer Testing

cd go_indexer
./test_config.sh                    # Configuration test
go test ./...                       # Unit tests
go test -cover ./...                # With coverage

Deployment

Programs

# Deploy to devnet
anchor deploy --provider.cluster devnet

# Deploy to mainnet
anchor deploy --provider.cluster mainnet

Frontend

# Build Docker image
docker build -t solana-frontend ./frontend

# Run container
docker run -p 3000:3000 \
  -e NEXT_PUBLIC_SOLANA_RPC_HOST=https://api.mainnet-beta.solana.com \
  -e NEXT_PUBLIC_SOLANA_NETWORK=mainnet-beta \
  solana-frontend

Indexer

# Using Docker Compose
cd go_indexer
docker-compose up -d

# Or build and run
go build -o indexer cmd/indexer/main.go
./indexer

Performance

Programs: 39+ tests passing, ~200ms avg execution time
Frontend: Lighthouse score 95+, Core Web Vitals optimized
Indexer: Processes 50+ transactions/second, <100ms latency

Resources

Official Documentation

Component Guides

Additional Resources

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 19 Commits
.github/workflows		.github/workflows
docs		docs
frontend @ da6e4bb		frontend @ da6e4bb
go_indexer @ 0de434f		go_indexer @ 0de434f
starter_program @ 94717ae		starter_program @ 94717ae
.env.docker		.env.docker
.gitignore		.gitignore
.gitmodules		.gitmodules
GITHUB_PAGES_FIX.md		GITHUB_PAGES_FIX.md
LICENSE		LICENSE
README.md		README.md
docker-compose.yml		docker-compose.yml
test-full-stack.sh		test-full-stack.sh

Folders and files

Latest commit

History

Repository files navigation

Solana Starter Program

Overview

Features

Anchor Programs

Frontend

Go Indexer

Quick Start

Prerequisites

1. Install Anchor

2. Build & Test Programs

3. Run Frontend

4. Run Indexer (Optional)

Project Structure

Programs

Starter Program

Counter Program

Usage Examples

Initialize Config

Create User Account (PDA)

Cross-Program Invocation

Mint Tokens

Frontend Hooks

Go Indexer Features

Event Indexing

Query Examples

Testing

Network Configuration

Programs (Anchor.toml)

Frontend (.env.local)

Security Features

Component Documentation

Architecture Overview

Key Features Highlight

1. Complete Solana Program Suite

2. Production-Ready Frontend

3. Scalable Event Indexer

Testing

Program Tests

Frontend Development

Indexer Testing

Deployment

Programs

Frontend

Indexer

Performance

Resources

Official Documentation

Component Guides

Additional Resources

Contributing

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages