Solana Finance plugin

Quicknode plugin and skill for Solana programs in Anchor 1, 2 and Quasar: accuracy, LiteSVM tests and compact Rust.

  • 101 ★ on the repository
  • Last commit
  • MIT
Plugin

Minimal access

Why this level

  • The skill contains only coding instructions and deploys nothing itself.
All reasons and checks

quicknode/solana-finance-claude-plugin

Install

Works in

In your terminal, with SkillFoxx CLI

npx skillfoxx add plugins/solana-finance

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Minimal accessThe tool runs nothing and makes no network calls.

  • The skill contains only coding instructions and deploys nothing itself.

This is third-party code. Review the repository files before installing.

What it does

The `solana` skill activates on its own when Claude Code works on a Solana, Anchor or Quasar project, or is invoked manually with `/solana-finance:solana`. It sets rules for financial programs: accuracy and consistency, security, readability and minimal code. Rust and LiteSVM are recommended for tests. The skill folder holds references for Anchor, Anchor 2.0.0-rc.1 (porting a program to the new version), Quasar, Rust and TypeScript. Separate files cover toolchain setup for CI and remote containers, summarizing programs and SVG account diagrams, including animation for a screen. The plugin accompanies the book "Building Financial Software on Solana".

Who it is for. Solana smart contract developers writing financial programs in Anchor or Quasar who want consistent rules from their agent.

Good fit when

  • A program on Anchor 1 is ported to Anchor 2.0.0-rc.1 and a sequence of steps is needed.
  • Tests for a program are written in Rust and LiteSVM rather than TypeScript.
  • An account diagram must be drawn in SVG and animated for a presentation.
  • A build environment is prepared for CI or a remote container.

Not a fit when

  • A security audit is needed; the skill sets writing rules and does not replace a third-party review.
  • The project is not on Solana; the rules target Anchor and Quasar.
  • On-chain data is wanted rather than coding help.

Example request

Port the escrow program from Anchor 1 to Anchor 2.0.0-rc.1, rewrite the tests on LiteSVM and describe the accounts with an SVG diagram.

Limitations

The skill contains instructions for writing and maintaining code and no deployment tooling: give an agent keys, wallets and networks separately and carefully. The rules target Anchor 1, Anchor 2.0.0-rc.1 and Quasar. Anchor 2 is marked as a release candidate. The skill follows the author's philosophy, for example demanding complete implementation with tests, which may differ from your team style. Installing through `npx skills@1.7.0` places files in the project `.claude/skills/`. The license is MIT.

How to disable. Run `/plugin uninstall solana-finance@quicknode`. A skill installed through `npx skills` is deleted from `.claude/skills/` or `~/.claude/skills/`.

FAQ

How do I install the plugin?

With two commands in Claude Code: `/plugin marketplace add quicknode/solana-finance-claude-plugin` and `/plugin install solana-finance@quicknode`.

Can only the skill be installed?

Yes, with `npx skills@1.7.0 add https://github.com/quicknode/solana-finance-claude-plugin`. The `-g` flag installs it for every project and `--agent claude-code` restricts it to one agent.

How do I invoke the skill manually?

With `/solana-finance:solana`. If the skill was installed on its own without the plugin the command is shorter: `/solana`.

Which frameworks are covered?

Anchor 1, Anchor 2 (release candidate) and Quasar, plus Rust and TypeScript for clients. Tests are recommended on LiteSVM.

What is a "smart contract" on Solana?

Solana programs play the role of what older blockchains call smart contracts. The plugin helps write them for financial products.

Discussion

No questions or reviews yet.

Plugins
Official

A Solana Foundation skill for Solana development: Anchor and Pinocchio, @solana/kit clients, wallets, Surfpool and LiteSVM testing, security

SkillExtended access590Repository stars

Agents, commands and MCP for Solana work in Claude Code, plus a firewall that fences secrets and the main network.

PluginBroad access111Repository stars

Skills for building and upgrading smart contracts on OpenZeppelin libraries in Solidity, Cairo, Stylus, Stellar and Sui

PluginExtended access223Repository stars
Official

Eight Stellar Development Foundation skills: Rust contracts, SDKs, RPC, assets, wallets and security reviews

SkillMinimal access59Repository stars

A Claude Code marketplace of 19 plugins and 76 skills for frontend, backend, DevOps and security, with a skill chain command

PluginExtended access530Repository stars

A plugin of 24 Claude Code skills for AI apps on Next.js, AI SDK 7, shadcn/ui and pgvector, with in-browser UI checks

PluginExtended access71Repository stars

README in short

The skill is tied to a book on financial software on Solana and based on code from large ecosystem programs. It consists of a `SKILL.md` entry point and a set of references by language and framework.

README badge

Original SKILL.md

---
name: solana
description: "Use when working on Solana software, including one or more of: Solana client code using TypeScript, Rust libraries that use Solana crates, Anchor programs, Quasar programs, LiteSVM tests, including Rust program files, TypeScript tests, and Anchor.toml or Quasar.toml configuration. Designed to create minimal, reusable code without unnecessary duplication."
---

# Coding Guidelines

Apply these rules to ensure code quality, maintainability, and adherence to project standards.

## Fight for Truth

Don't write things that aren't currently true - anywhere. Chat, code comments, variable names, PR titles, READMEs, commit messages.

- Documentation and comments that do not match the code are considered untrue.
- Variable names that do not match the purpose of the variable are considered untrue. For example, a struct called `InitializeMarket` is not true because a struct cannot 'initialize a market' - structs do not do things, only functions can do things.
- Temporary workarounds that aren't labelled as such are lying through omission - there is an issue you aren't telling the next programmer about. Mark them with a `TODO` comment with a link to a git issue (if it exists) and telling the next programmer when they can delete the workaround.
- If unsure of something, say so. Bluffing is lying.
- **Ambiguity is a soft lie:** if a phrase could be read two ways and only one is true, it's misleading. Disambiguate before sending - pick the term that says exactly what's meant, name the antecedent of every "it"/"this"/"that".
- A wrong statement is worse than no statement.
- Separate scratch labels from real identifiers.

Actively fix untrue things when you see them. Don't let "close enough" wording stand in for the truthful one.

**Grep before naming.** Before sending any prose, walkthrough, README, comment, or commit message that names a specific identifier (function, struct, file, account, module, field, constant), grep the source for that exact identifier and confirm it exists. "I'm pretty sure that's the name" is not enough. If the identifier doesn't exist, either use the real name or apply the rename to the code first, then write the prose.

**Describe what is, not what was removed.** READMEs, doc-comments, and code comments document current state - not history. Lines like "no floats", "no longer uses X", "replaces the previous Y approach" belong in CHANGELOGs and PR descriptions, not source artefacts. A first-time reader has no history and "no longer uses I64F64" creates ambient confusion ("wait, should I be worried?"). Sweep before sending: grep for `no longer`, `removed`, `previously`, `used to`, `formerly`, `dropped`, `now uses`, `replaces the previous` - each hit is a candidate for deletion.

## Do the whole thing

The marginal cost of completeness is near zero with AI. Do the whole thing.

Do it right. Do it with tests. Do it with documentation. Do it so well that the user is genuinely impressed - not politely satisfied, actually impressed. Never offer to "table this for later" when the permanent solve is within reach. Never leave a dangling thread when tying it off takes five more minutes. Never present a workaround when the real fix exists.

The standard isn't "good enough" - it's "holy shit, that's done." Search before building. Test before shipping.

Ship the complete thing. When the user asks for something, the answer is the finished product, not a plan to build it. Time is not an excuse. Fatigue is not an excuse. Complexity is not an excuse. Boil the ocean.

**A caveat is not a fix.** When you find a gap while doing the work - missing test coverage, a CI job that doesn't run, an untested path, a stale doc - close it as part of the task. Do not downgrade a fixable defect into a disclaimer. If you catch yourself writing "note: X isn't covered / isn't built / isn't tested / won't get a CI signal," stop: that sentence is a TODO, not a caveat. Fix X so there is nothing to note. Reserve caveats for what you genuinely cannot fix (out of scope, needs a decision, external blocker) - and for those, state what you would do and offer to do it.

## Success Criteria

Report a problem