New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Shredstream

by agiprolabs in agiprolabs/claude-trading-skills

Pre-execution Solana transaction streaming via Jito ShredStream, Shyft RabbitStream, and Triton Deshred

MITAuto-check: notesBackend & APIs

Install Shredstream

skills CLI
$ npx skills add agiprolabs/claude-trading-skills --skill shredstream -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install agiprolabs/claude-trading-skills shredstream --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/agiprolabs/claude-trading-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/shredstream .claude/skills/shredstream && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
shredstream
GitHub stars
410
Token cost
~2.5k tokens
SKILL.md length
578 words
Files
6 (incl. scripts, references)
Skills in repo
68
Repo updated
First seen
Licence
MIT

At a glance

Pre-execution Solana transaction streaming via Jito ShredStream, Shyft RabbitStream, and Triton Deshred

  • Works in 4 steps: Generate a Solana keypair: solana-keygen… → Apply at Jito's form with your public key → Wait for approval (your keypair gets… → …
  • Backend & APIs work in your project
  • SKILL.md covers How It Works, Three Ways to Get…, Option 1: Jito ShredStream Proxy and Option 2: Shyft RabbitStream, plus 5 more sections
  • Runs Python scripts from its folder; calls git, cargo and docker; reaches mainnet.block-engine.jito.wtf and github.com; needs GRPC_TOKEN

What it does

Shredstream is an agent skill from agiprolabs/claude-trading-skills. Pre-execution Solana transaction streaming via Jito ShredStream, Shyft RabbitStream, and Triton Deshred

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including scripts and reference files (for example `references/deployment.md`, `references/proto_reference.md` and `references/providers_compared.md`).

It sits in Backend & APIs. It works with Solana and gRPC. The repository describes itself as: 68 trading, DeFi, and quantitative finance Agent Skills. Works with Claude Code, Cursor, Codex, Gemini CLI, and 30+ other tools. The licence is MIT.

When your agent uses it

  • Backend & APIs work in your project

Example prompts

  • “/shredstream”

Requirements

  • Python 3
  • Docker
  • A credential in GRPC_TOKEN

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Generate a Solana keypair: solana-keygen new -o shred_auth.json
  2. Apply at Jito's form with your public key
  3. Wait for approval (your keypair gets whitelisted)
  4. No staking requirement, free during beta

What it can do on your machine

Read from SKILL.md and the folder at commit 981e1d7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • git
    • cargo
    • docker

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • mainnet.block-engine.jito.wtf
    • github.com
    • rabbitstream.ny.shyft.to

    Also links to:

    • web.miniextensions.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • GRPC_TOKEN

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Shredstream loads about 2.5k tokens when it runs, and up to ~6.9k if it reads all its reference files. Until then it costs about 29 tokens; SKILL.md has 578 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~29
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteRuns commands with sudoSKILL.md:110
    sudo tcpdump 'udp and dst port 20000'

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from agiprolabs/claude-trading-skills at commit 981e1d7, republished under its MIT licence (© agiprolabs). 578 words, ~2,509 tokens.

Download SKILL.mdSave it as .claude/skills/shredstream/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
shredstream
description
Pre-execution Solana transaction streaming via Jito ShredStream, Shyft RabbitStream, and Triton Deshred

ShredStream — Pre-Execution Solana Data

ShredStream gives you transaction data before the validator executes the block — typically 100-500ms earlier than standard Yellowstone gRPC. You see transaction intent, not confirmed results.

This is the fastest path to Solana data for time-critical trading strategies.

How It Works

Solana validators produce blocks by serializing transactions into shreds (~1,228 bytes each, sized for UDP MTU). Shreds propagate through Turbine (Solana's fanout protocol, 2-3 hops). ShredStream bypasses Turbine by receiving shreds directly from leader validators via Jito's Block Engine.

Leader Validator
     │
     ├── Turbine (standard, 2-3 hops, 200-500ms)
     │       └── Your RPC Node → Yellowstone gRPC (post-execution)
     │
     └── Jito Block Engine (direct)
              └── ShredStream Proxy (your server)
                   ├── UDP shreds → Your RPC/Validator (faster block building)
                   └── gRPC entries → Your Trading Bot (decoded transactions)
What You Get vs. What You Don't
Available (Pre-Execution)NOT Available (Needs Execution)
Transaction signaturesSuccess/failure status
Account keys (pubkeys)Balance changes (pre/post)
Instructions (program, accounts, data)Log messages
Address lookup table referencesInner instructions (CPI)
Slot numberToken balance changes
Compute units consumed

Key tradeoff: Speed for completeness. You see what's about to happen but can't confirm it actually succeeded. Some transactions you see will ultimately fail.

Three Ways to Get Pre-Execution Data

ProviderProductLatencyAccessCost
JitoShredStream Proxy~10-50ms from leaderApply + auth keypairFree (beta)
ShyftRabbitStream~15-100ms faster than gRPCShyft gRPC planFrom $199/mo
TritonDeshred (SubscribeDeshred)~6.3ms p50 from shredTriton customer~$2,900+/mo

See references/providers_compared.md for detailed comparison.

Option 1: Jito ShredStream Proxy

The most direct approach — run Jito's open-source proxy on your own server.

Get Access
  1. Generate a Solana keypair: solana-keygen new -o shred_auth.json
  2. Apply at Jito's form with your public key
  3. Wait for approval (your keypair gets whitelisted)
  4. No staking requirement, free during beta
Run the Proxy
bash
# Clone and build
git clone https://github.com/jito-labs/shredstream-proxy.git --recurse-submodules
cd shredstream-proxy

# Run with gRPC enabled (key flag: --grpc-service-port)
RUST_LOG=info cargo run --release --bin jito-shredstream-proxy -- shredstream \
    --block-engine-url https://mainnet.block-engine.jito.wtf \
    --auth-keypair /path/to/shred_auth.json \
    --desired-regions ny,amsterdam \
    --dest-ip-ports 127.0.0.1:8001 \
    --grpc-service-port 7777

Docker (host networking required for UDP):

bash
docker run -d --name shredstream-proxy --rm \
  --network host \
  -e RUST_LOG=info \
  -e BLOCK_ENGINE_URL=https://mainnet.block-engine.jito.wtf \
  -e AUTH_KEYPAIR=/app/shred_auth.json \
  -e DESIRED_REGIONS=ny,amsterdam \
  -e DEST_IP_PORTS=127.0.0.1:8001 \
  -e GRPC_SERVICE_PORT=7777 \
  -v /path/to/shred_auth.json:/app/shred_auth.json \
  jitolabs/jito-shredstream-proxy shredstream
Configuration
ParameterDescriptionExample
BLOCK_ENGINE_URLJito block engine endpointhttps://mainnet.block-engine.jito.wtf
AUTH_KEYPAIRPath to whitelisted Solana keypairshred_auth.json
DESIRED_REGIONSMax 2, comma-separatedny,amsterdam
DEST_IP_PORTSWhere to forward raw shreds (UDP)127.0.0.1:8001
GRPC_SERVICE_PORTEnable gRPC entry streaming7777
SRC_BIND_PORTIncoming shred UDP port20000

Available regions: amsterdam, dublin, frankfurt, london, ny, salt-lake-city, singapore, tokyo

Verify It's Working
bash
# Check shreds are arriving via UDP
sudo tcpdump 'udp and dst port 20000'
# Should see many ~1200-byte packets continuously
Consume via gRPC
rust
use jito_protos::shredstream::{
    shredstream_proxy_client::ShredstreamProxyClient,
    SubscribeEntriesRequest,
};

let mut client = ShredstreamProxyClient::connect("http://127.0.0.1:7777").await?;
let mut stream = client
    .subscribe_entries(SubscribeEntriesRequest {})
    .await?
    .into_inner();

while let Some(entry) = stream.message().await? {
    let entries: Vec<solana_entry::entry::Entry> =
        bincode::deserialize(&entry.entries)?;

    for e in &entries {
        for tx in &e.transactions {
            let sig = tx.signatures[0];
            let msg = tx.message();
            // Parse instructions, accounts, etc.
        }
    }

    println!("Slot {}: {} entries, {} transactions",
        entry.slot,
        entries.len(),
        entries.iter().map(|e| e.transactions.len()).sum::<usize>()
    );
}

Option 2: Shyft RabbitStream

Drop-in replacement for Yellowstone gRPC — same SubscribeRequest format, just a different endpoint. Easiest way to get pre-execution data without running infrastructure.

bash
export GRPC_ENDPOINT="https://rabbitstream.ny.shyft.to"
export GRPC_TOKEN="your-shyft-x-token"
python
# Same code as yellowstone-grpc, just different endpoint
import grpc

endpoint = "rabbitstream.ny.shyft.to"
token = os.environ["GRPC_TOKEN"]

# ... standard Yellowstone connection code ...
# Subscribe to transactions — same filter format
request = SubscribeRequest(
    transactions={
        "pumpfun": SubscribeRequestFilterTransactions(
            account_include=["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
            vote=False,
            failed=False,
        )
    },
    commitment=CommitmentLevel.PROCESSED,
)

Limitations: Only transaction filters work. No account, slot, or block subscriptions. The meta field is empty (no execution results).

Regional endpoints: rabbitstream.{ny,va,ams,fra}.shyft.to

Show full SKILL.md (213 more words)Show less

Option 3: Triton Deshred

Lowest latency (~6.3ms p50) via Triton's SubscribeDeshred RPC. Same Yellowstone client, different method.

rust
// Requires yellowstone-grpc-client with Deshred support
let (mut tx, mut stream) = client.subscribe_deshred().await?;

tx.send(SubscribeDeshredRequest {
    deshred_transactions: hashmap!{
        "pumpfun".to_string() => SubscribeRequestFilterDeshredTransactions {
            vote: Some(false),
            account_include: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".into()],
            ..Default::default()
        }
    },
    ..Default::default()
}).await?;

Access: Triton customers only, paid beta, requires their custom Agave validator fork.

Parsing Pre-Execution Transactions

Without execution metadata, parsing is simpler but requires program-specific knowledge.

Identify the Program
python
# From a raw VersionedTransaction (post-deserialization)
account_keys = [str(k) for k in tx.message.account_keys]
for ix in tx.message.instructions:
    program_id = account_keys[ix.program_id_index]
    if program_id == "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P":
        # This is a PumpFun instruction
        discriminator = ix.data[:8]
        # Decode instruction data per PumpFun IDL
Instruction Discriminators

Most Solana programs use 8-byte discriminators (Anchor SHA256 hash of the instruction name). Match instruction.data[:8] against known values for each program.

python
# Common approach
PUMPFUN_CREATE = bytes.fromhex("181ec828051c0777")
PUMPFUN_BUY = bytes.fromhex("66063d1201daebea")
PUMPFUN_SELL = bytes.fromhex("33e685a4017f83ad")

disc = ix.data[:8]
if disc == PUMPFUN_BUY:
    # Parse buy parameters from remaining bytes
    ...

Warning: Discriminator values are program-specific and can change between program versions. Always verify against the current program IDL. See the pumpfun-mechanics skill for PumpFun-specific parsing.

Common Architecture: ShredStream + Yellowstone

Most production systems use both:

ShredStream (pre-execution)          Yellowstone gRPC (post-execution)
         │                                      │
         ▼                                      ▼
  Intent Detection                    Confirmation + Reconciliation
  "Wallet X is buying token Y"       "Buy succeeded, wallet now holds Z"
         │                                      │
         ▼                                      ▼
  Pre-compute Response                Execute / Update State
  (route, sign, prepare bundle)       (record PnL, update positions)

This gives you the speed advantage of ShredStream for signal detection while using Yellowstone for reliable state management.

Deployment Requirements

  • Public IP required — NAT breaks UDP shred delivery
  • Host networking — Docker bridge mode drops shred packets
  • UDP port 20000 open for incoming shreds
  • Co-locate near validators — Frankfurt, NY, Amsterdam, London, Tokyo recommended
  • Bare metal preferred — Cloud VMs add 1-5ms jitter from shared NICs

See references/deployment.md for full infrastructure guide.

Files

References
  • references/providers_compared.md — Jito ShredStream vs Shyft RabbitStream vs Triton Deshred
  • references/deployment.md — Infrastructure requirements, region selection, firewall configuration
  • references/proto_reference.md — ShredStream protobuf definitions and Entry parsing
Scripts
  • scripts/parse_shredstream_entries.py — Decode and analyze ShredStream gRPC entries
  • scripts/rabbitstream_monitor.py — Connect to Shyft RabbitStream for pre-execution transaction monitoring

© agiprolabs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in skills/shredstream of agiprolabs/claude-trading-skills.

  • SKILL.md
  • references/deployment.md
  • references/proto_reference.md
  • references/providers_compared.md
  • scripts/parse_shredstream_entries.py
  • scripts/rabbitstream_monitor.py

Open the folder on GitHubat commit 981e1d7

Compare with similar skills

Shredstream next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Shredstream compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Shredstream this skillagiprolabs/claude-trading-skills410—~2.5kAutomated safety check: NotesMIT
Release Rebasejito-foundation/geyser-grpc-plugin145—~836Automated safety check: PassCustom licence
Quicknode Skillinternet-court/internet-court-skill6.5k—~11kAutomated safety check: PassMIT
Quicknodesendaifun/skills1301 repos~5.5kAutomated safety check: NotesApache-2.0
Use Yaakmountain-loop/yaak19k—~1.9kAutomated safety check: PassMIT
Golang Proantoniopaya22/go-rest-template1723 repos~1.2kAutomated safety check: PassMIT

Similar skills

  • Release Rebase

    jito-foundation/geyser-grpc-plugin

    A skill your agent uses when updating this repo to match a new jito-solana release line such as v4.0.

    145 GitHub stars~836 tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

  • Quicknode Skill

    internet-court/internet-court-skill

    Quicknode blockchain infrastructure for 80+ chains: Core RPC API, Streams, Webhooks, Blazar WSS, Solana gRPC, HyperCore gRPC, SQL Explorer, Metaplex DAS API, Blockbook, Ordinals & Runes API, Swap…

    6.5k GitHub stars~11k tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

  • Quicknode

    sendaifun/skills

    Quicknode blockchain infrastructure for Solana — RPC endpoints, DAS API (Digital Asset Standard) for NFTs and compressed assets, Yellowstone gRPC streaming, Priority Fee API, Streams (real-time data…

    130 GitHub starsUsed in 1 repo~5.5k tokens
    Backend & APIsAuto-check: notes

  • Use Yaak

    mountain-loop/yaak

    A skill your agent uses when the user mentions Yaak, a Yaak workspace, or the yaak command, or asks to call, hit, or smoke test HTTP/REST endpoints, save or organize API requests for reuse or manual…

    19k GitHub stars~1.9k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • Golang Pro

    antoniopaya22/go-rest-template

    Implements concurrent Go patterns using goroutines and channels, designs and builds microservices with gRPC or REST, optimizes Go application performance with pprof, and enforces idiomatic Go with…

    172 GitHub starsUsed in 3 repos~1.2k tokens
    Backend & APIsAuto-check passed

  • Debug Grpc Connection

    GetBindu/Bindu

    Diagnose gRPC connection issues between the Bindu core and a language SDK.

    10k GitHub stars~1.2k tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

More from agiprolabs/claude-trading-skills

All 68 skills in this repo

  • Backtrader

    agiprolabs/claude-trading-skills

    Event-driven backtesting with bar-by-bar execution, complex order types, multiple analyzers, and custom indicators

    410 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Birdeye API

    agiprolabs/claude-trading-skills

    Solana token market data via Birdeye — prices, OHLCV, trades, token metadata, security checks, and trader activity

    410 GitHub stars~1.8k tokensUpdated 1 mo ago
    Auto-check passed

  • Coingecko API

    agiprolabs/claude-trading-skills

    Broad crypto market data from CoinGecko covering 13,000+ tokens.

    410 GitHub stars~1.6k tokensUpdated 1 mo ago
    Auto-check passed

  • Cointegration Analysis

    agiprolabs/claude-trading-skills

    Cointegration testing for pairs trading using Engle-Granger, Johansen, and rolling stability analysis

    410 GitHub stars~2.1k tokensUpdated 1 mo ago
    Auto-check passed

  • Copy Trading

    agiprolabs/claude-trading-skills

    Wallet evaluation, monitoring, and copy-trade strategy design for Solana DEX trading

    410 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Correlation Analysis

    agiprolabs/claude-trading-skills

    Cross-asset correlation analysis including rolling correlation, hierarchical clustering, tail dependence, and regime-dependent correlation

    410 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Shredstream

What does Shredstream do?

Pre-execution Solana transaction streaming via Jito ShredStream, Shyft RabbitStream, and Triton Deshred. Shredstream is an agent skill from agiprolabs/claude-trading-skills.

When should I use Shredstream?

Shredstream fits situations like: backend & APIs work in your project.

How do I install Shredstream in Claude Code?

Run `npx skills add agiprolabs/claude-trading-skills --skill shredstream -a claude-code`. Or copy the skill folder (skills/shredstream in agiprolabs/claude-trading-skills) into .claude/skills/shredstream in your project. Claude Code loads it when a task matches its description.

How do I install Shredstream in Codex?

Run `npx skills add agiprolabs/claude-trading-skills --skill shredstream -a codex`. Or copy the skill folder (skills/shredstream in agiprolabs/claude-trading-skills) into .agents/skills/shredstream in your project. Codex loads it when a task matches its description.

Can I use Shredstream in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add agiprolabs/claude-trading-skills --skill shredstream -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/shredstream, .gemini/skills/shredstream, .github/skills/shredstream and .opencode/skills/shredstream in your project.

What does Shredstream need to run?

Going by SKILL.md and its folder, Shredstream needs Python for the scripts in its folder, the command-line tools its instructions call (git, cargo and docker) and credentials named GRPC_TOKEN. Our summary lists: Python 3; Docker; A credential in GRPC_TOKEN.

Does Shredstream access the network?

SKILL.md names 4 domains. In commands or code: mainnet.block-engine.jito.wtf, github.com and rabbitstream.ny.shyft.to; the agent is likely to contact these when it follows the instructions. As links in the text: web.miniextensions.com. This is read from the text; nothing was executed.

Is Shredstream safe to install?

Our automated static check of SKILL.md found notes only (runs commands with sudo), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Shredstream use?

Shredstream is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Shredstream use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.4k tokens, read only when the agent opens those files.

What are the alternatives to Shredstream?

Skills that share tags, products or a category with Shredstream: Release Rebase (jito-foundation/geyser-grpc-plugin, 145 stars), Quicknode Skill (internet-court/internet-court-skill, 6.5k stars), Quicknode (sendaifun/skills, 130 stars) and Use Yaak (mountain-loop/yaak, 19k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Shredstream?

agiprolabs (a GitHub user) maintains it in agiprolabs/claude-trading-skills, which has 410 GitHub stars. The repository holds 68 skills in this directory. The repository was last updated on September 3, 2026.

Source: agiprolabs/claude-trading-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.