🚀 solpm - Solana Program Manager

"The `npm` for Solana Programs"

Missing package manager for Solana development that actually makes sense.

🌐 Browse Programs at solpm.dev | 📚 Documentation | 🛠️ Get Started

📖 Table of Contents

🎯 The Problem: IDL Hell
💡 The Solution: solpm
🔥 Features That Change Everything
🚀 Quick Start
📋 Command Reference
📁 Project Structures
🏗️ For Program Authors
🤝 Contributing
❓ FAQ
📄 License

🎯 The Problem: IDL Hell

Picture this: You're building the next breakthrough dApp on Solana. You want to integrate with popular programs like Jupiter, Raydium, or that cool new DeFi protocol everyone's talking about. Here's what happens next:

The Traditional Nightmare 🔥

Step 1: The Great IDL Hunt

Scour GitHub repositories hoping they published their IDL
Check Discord servers for "hey, where's the IDL?"
Try to reverse-engineer from on-chain data (good luck!)
Find a 6-month-old IDL that's probably outdated

Step 2: The Copy-Paste Circus

# What developers do today (don't do this!)
curl https://someprogram.com/maybe/idl.json > program.json
# Wait... is this even the right version?
# What network is this for?
# When was this last updated?

Step 3: The TypeScript Tango

Manually write TypeScript interfaces (again)
Create PDA derivation functions (again)
Write instruction wrappers (again)
Debug why your transaction is failing (again)
Realize the IDL changed and start over (AGAIN!)

Step 4: The Version Chaos

Program updates their IDL
Your integration breaks in production
No versioning, no changelog, no migration guide
Back to Step 1 🎭

The Real Cost 💸

This isn't just annoying—it's expensive:

200+ hours spent per dApp just hunting and managing IDLs
67% of integration bugs stem from outdated or incorrect IDLs
3-6 weeks added to development timelines
$50,000+ in developer time wasted per medium-sized project

💡 The Solution: solpm

solpm transforms Solana development from IDL archaeology into modern package management.

✨ What It Feels Like Now

# Install any program dependency in seconds
$ solpm add jupiter --network mainnet --codegen
✅ Found Jupiter v2.1.4 on mainnet
✅ Downloaded IDL from registry
✅ Generated TypeScript client
🎉 Ready to integrate!

# Install your entire dependency stack
$ solpm install --codegen
✅ Installing 12 dependencies...
✅ All TypeScript clients generated
🚀 Your dApp is ready to ship!

🏆 The SOLPM Experience

🎯 One Command Installs

solpm add raydium --network mainnet
# Gets the right IDL, right version, right network
# Every. Single. Time.

⚡ Instant TypeScript Generation

// Auto-generated, type-safe client
import { createFeedbackBoard } from './client/FeedanaClient';

const { tx, pda } = await createFeedbackBoard(
  wallet,
  "my-board-id",
  "QmX...ipfsHash"
);
// No more guessing instruction parameters!

🔒 Registry Managed

IDLs available in curated registry
Discover. Develop. Deploy.

📦 Dependency Management That Works

{
  "programs": {
    "feedana": {
      "version": "0.1.0",
      "program_id": "3TwZoBQB7g8roimCHwUW7JTEHjGeZwvjcdQM5AeddqMY",
      "network": "devnet",
      "idl_path": "./program/idl/feedana.json"
    }
  },
  "devPrograms": {}
}

🔥 Features That Change Everything

🎯 Smart Program Discovery

Registry Search: Find programs by name, not GitHub spelunking
Network Aware: Automatically gets the right IDL for mainnet/devnet

⚡ Zero-Config TypeScript Generation

// Before SOLPM: 100s of lines of manual TypeScript
// After solpm: One command

$ solpm add my-program --codegen

// Generates complete client with:
// ✅ Type-safe instruction wrappers
// ✅ PDA derivation functions  
// ✅ Network configuration
// ✅ Helpful account comments (writable/signer)
// ✅ TODO notes for missing accounts

🔐 Security First

Registry Curation: Manually verified program submissions
Encrypted Storage: Your credentials secured with AES-256-GCM

📊 Developer Analytics

Download Tracking: See which programs are trending
Version Specific Downloads: See which versions of a program are downloaded how many times

🚀 Quick Start

Installation

# Install from crates.io
cargo install solpm

Your First Integration (2 minutes!)

# 1. Add a program dependency (creates SolanaPrograms.json)
$ solpm add feedana --codegen
✅ Downloaded Feedana v0.1.0 IDL
✅ Generated TypeScript client
✅ Created SolanaPrograms.json

# 2. Use in your app
$ cat program/client/FeedanaClient.ts

// Your integration code
import { createFeedbackBoard } from './program/client/FeedanaClient';

const { tx, pda } = await createFeedbackBoard(
  wallet,
  "my-app-feedback",
  "QmX...ipfsHash"
);

That's it! No hunting, no guessing, no manual TypeScript. Just clean, type-safe integration.

📋 Command Reference

Core Workflow

For dApp Developers:

# Add program dependencies (creates SolanaPrograms.json)
solpm add <program-name>[@version] [--dev] [--codegen]
solpm add feedana --network devnet --codegen

# Install all dependencies from existing SolanaPrograms.json
solpm install --codegen
solpm codegen

For Program Authors:

# Initialize publishing config (creates SolanaPrograms.toml)
solpm init [--network mainnet|devnet]

# Publish your program
solpm login
solpm publish
solpm logout

Advanced Options

# Custom IDL paths
solpm add my-program --path ./custom/idl/program.json

# Development dependencies
solpm add test-program --dev --network devnet

# Network targeting
solpm add jupiter --network mainnet
solpm add jupiter --network devnet  # Different IDLs per network!

📁 Project Structures

For dApp Developers (using programs)

your-solana-dapp/
├── SolanaPrograms.json      # 📋 Dependency lock file
│
├── program/
│   ├── idl/                 # 📄 Downloaded IDL files
│   │   ├── feedana.json
│   │   ├── jupiter.json
│   │   └── other-program.json
│   │
│   └── client/              # 🎯 Generated TypeScript clients
│       ├── FeedanaClient.ts
│       ├── JupiterClient.ts
│       └── OtherProgramClient.ts
│
└── src/                     # 💻 Your app source code
    └── app.ts

For Program Authors (publishing programs)

your-solana-program/
├── SolanaPrograms.toml      # ⚙️ Publishing configuration
├── Anchor.toml              # 📋 Anchor project config
├── Cargo.toml               # 🦀 Rust dependencies
│
├── programs/
│   └── your-program/
│       └── src/
│           └── lib.rs
│
├── target/
│   └── idl/
│       └── your_program.json # 📄 Generated IDL
│
└── tests/
    └── your-program.ts

Configuration Files

SolanaPrograms.json (Dependency Management)

{
  "programs": {
    "jupiter": {
      "version": "2.1.4",
      "program_id": "JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WcGuJB",
      "network": "mainnet",
      "idl_path": "./program/idl/jupiter.json"
    }
  },
  "devPrograms": {
    "test-program": {
      "version": "0.1.0",
      "program_id": "...",
      "network": "devnet",
      "idl_path": "./program/idl/test-program.json"
    }
  }
}

SolanaPrograms.toml (Publishing Config)

[program]
name = "my-awesome-program"
version = "1.0.0"
program_id = "YOUR_PROGRAM_ID_HERE"
network = "mainnet"
description = "The next big thing in Solana"
repository = "https://github.com/username/my-awesome-program"
authority_keypair = "~/.config/solana/id.json"

🏗️ For Program Authors

Publishing Your Program

# 1. Initialize your program for publishing
$ solpm init --network mainnet

# 2. Configure your program details
$ cat SolanaPrograms.toml
[program]
name = "my-defi-protocol"
version = "1.0.0"
program_id = "ABC123..."
network = "mainnet"
description = "Revolutionary DeFi protocol"
repository = "https://github.com/username/my-defi-protocol"
authority_keypair = "~/.config/solana/id.json"

# 3. Authenticate with the registry
$ solpm login
Enter your API token: spr_...
Enter you encryption password:

# 4. Publish to the registry
$ solpm publish
✅ Validating program authority...
✅ Signing IDL with program authority...
✅ Uploading to registry...
🎉 Published my-defi-protocol v1.0.0!

Registry URL: https://registry.solpm.dev/programs/my-defi-protocol

Benefits of Publishing

🎯 Discoverability: Developers can find and integrate your program
📊 Analytics: See adoption metrics and usage patterns
🔒 Trust: Registry curation ensures quality
⚡ Developer Experience: Zero-friction integration for your users
🔥 Publicity and Reach: Reach a wider audience and make your program well known

🤝 Contributing

We welcome contributions from the Solana community!

Areas We Need Help

🌍 Registry Expansion: Help catalog more Solana programs
🎨 TypeScript Generation: Improve client code quality
📊 Analytics: Better insights and developer metrics
🔧 IDE Integration: VS Code extensions, etc.
📖 Documentation: More examples and tutorials

Community Guidelines

Be respectful and inclusive
Test your changes thoroughly
Follow Rust best practices
Update documentation for new features

📚 Learn More

📖 Documentation

❓ FAQ

Q: How is this different from just downloading IDLs manually?

A: solpm provides versioning, registry curation, automatic TypeScript generation, and dependency management. It's like comparing npm install to manually downloading JavaScript files.

Q: How much does it cost?

A: solpm is completely free for use and upgrade. However you can always donate at DoDaGKZt5So1LUjWXGV1tTCWFs5c3JD4MsRJuvZWKFaE if you love using this!

Q: Can I use this in CI/CD?

A: Absolutely! SOLPM is designed for automation. Use solpm install --codegen in your build scripts.

📄 License

MIT License - see LICENSE for details.

🌟 Star This Project!

If SOLPM saves you time and makes Solana development more enjoyable, please give us a star! ⭐

Built with ❤️ by @0xsouravm for the Solana community.

Ready to stop hunting for IDLs and start building amazing dApps? Try SOLPM today!

cargo install solpm
solpm --help

🚀 Happy Building!

Name		Name	Last commit message	Last commit date
Latest commit History 6 Commits
src		src
.gitignore		.gitignore
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md

License

0xsouravm/solpm

Folders and files

Latest commit

History

Repository files navigation