DEV Community: Jayen Harrill

thinking about rolling time windows for dex data in substrate-based chains

Jayen Harrill — Fri, 20 Mar 2026 22:40:02 +0000

been spending time with streaming DEX data lately and one thing that kept tripping me up was how to handle time-bucketed metrics cleanly. most real-time price feeds just give you point-in-time prices, which is fine until you need to answer questions like "what's the 1h volume for this pair" or "how has liquidity moved over the last 5 minutes" without building your own aggregation layer.

the pattern i've seen work best is pre-computing rolling windows server-side across multiple horizons (5m, 1h, 6h, 24h) and streaming those as part of the pair update payload. that way your subscriber doesn't have to maintain state across potentially thousands of pairs simultaneously. the tradeoff is you're trusting the upstream aggregation logic and you lose some flexibility if you want non-standard windows.

for anyone building trading bots or dashboards on DEXes, this distinction matters more than it seems. block times are shorter than most EVM chains, so the 5-minute window in particular captures meaningfully more trades than you'd expect on something like ethereum mainnet. that affects how you set alert thresholds.

one thing i'd flag as a limitation: rolling windows calculated on the streaming side can have edge-case behavior right at window boundaries, especially if there's a lag spike or a brief websocket disconnect. you usually want to reconcile against a historical endpoint periodically rather than treating the streamed aggregates as ground truth for anything high-stakes.

i noticed GoldRush pushed an update to their updatePairs streaming endpoint that adds exactly this kind of multi-window metric support.

https://goldrush.dev/docs/changelog/20260313-rich-trading-metrics-for-updatepairs

for those of you running bots on DEXes, how are you handling time-bucketed aggregation currently, client-side or offloading it upstream?

GoldRush Skills: Structured Knowledge for AI Agents

Jayen Harrill — Fri, 06 Mar 2026 23:43:37 +0000

LLMs have broad knowledge but shallow precision. GoldRush Agent Skills give AI agents the context they need to use the APIs to access onchain data.

AI agents are only as good as the context you give them. Ask an agent to fetch a wallet's token balances and it will try. It will guess at endpoint paths, hallucinate query parameters, and pick the wrong API entirely. Not because the model is bad, but because it has no reference material to work from.

That changes today. We're releasing GoldRush Agent Skills: four structured documentation packages that give AI agents the context they need to use GoldRush APIs correctly. Install once, and your agent knows every endpoint, every parameter, every credit cost, and when to use which product.

The Problem

LLMs have broad knowledge but shallow precision. When an agent needs to call a blockchain API, it's working from training data that may be outdated, incomplete, or just wrong. The result: failed requests, wrong chains, missing parameters, wasted credits.

Agent Skills solve this by putting a structured reference directly into the agent's context window. No web scraping. No RAG pipelines. Just a spec-compliant skill file the agent reads before making any call.

Four Skills, Full Coverage

Each skill maps to a GoldRush product:

Foundational API: REST endpoints for historical blockchain data. Balances, transactions, NFTs, token prices, security checks, cross-chain queries across 100+ networks.
Streaming API: Real-time GraphQL subscriptions. OHLCV candles, new DEX pairs, wallet activity monitoring, token search, and PnL queries via WebSocket.
x402: Pay-per-request access without API keys. Agents pay with stablecoins using the HTTP 402 protocol. No accounts, no rate limits, no key management.
CLI: Terminal-first blockchain data with native MCP support. 17 commands that work for both humans and AI agents.

Every skill includes routing logic (when to use this product vs. another), operation identity (HTTP method, path, SDK method), pricing awareness (credit costs per call), and workflow patterns (multi-step examples for complex tasks).

Why This Is Different

Most "AI integrations" are wrappers around existing docs or links to reference pages. Agent Skills are purpose-built for the agent context window:

Spec-compliant. Built on the Agent Skills standard. Works with Claude Code, Cursor, VS Code, Gemini CLI, OpenAI Codex, and Roo Code.
Self-contained. No external links to follow. No HTML to parse. Everything the agent needs is in the skill file.
Routing-aware. The agent knows that real-time DEX data goes through Streaming, historical balances go through the Foundational API, and keyless access goes through x402.
Pricing-aware. The agent can estimate credit costs before making calls and choose efficient query patterns.

Install

One command. Works with any agent that supports the Agent Skills standard.

npx skills add covalenthq/goldrush-agent-skills
Skills are also available directly at GoldRush Agents Hub.

After install, just describe what you need in natural language. "Get me the top token holders for USDC on Ethereum." "Stream new DEX pairs on Base." "What's the 24h price history for WETH?" The agent picks the right skill, the right endpoint, and the right parameters automatically.

Setup Guides for Every Agent
We've also launched dedicated setup guides for each supported coding agent. Whether you're using Claude Code, Cursor, Codex, Windsurf, Cline, GitHub Copilot, Devin, or OpenClaw, there's a page with agent-specific install steps, example prompts, and available tools.

Start from the GoldRush Agents hub or jump directly to your agent:

Each guide covers MCP Server setup (for real-time tool access) and Agent Skills install (for structured API knowledge). Two layers that work together: the MCP Server gives your agent 27+ onchain data tools, and Agent Skills give it the context to use them correctly.

What's Next
Agent Skills ship today as a public package on skills.sh. We'll continue expanding coverage as new GoldRush endpoints launch, and we're exploring tighter integrations with agent frameworks like LangChain, CrewAI, and the Anthropic Agent SDK.

The goal is simple: make GoldRush the default blockchain data layer for AI agents. Not because we told them to use it, but because the context is already there.

Get started with Agent Skills

We built a CLI for blockchain access in one command

Jayen Harrill — Thu, 26 Feb 2026 23:34:34 +0000

I work on GoldRush at Covalent, and we just shipped a new CLI focused on agent workflows where you need to debug and check onchain or pricing data quickly or pass the data to the agent via MCP.

We wanted to reduce setup friction so agents can start using blockchain data and actions without a long integration cycle.

What it does (high level):

CLI-first workflow for agent builders
Fast setup path from zero to working integration
Works alongside MCP/LLM agent stacks

full walkthrough here

If you’re building agent tooling, I’d love feedback on:

setup UX
missing commands
which agent frameworks you want first-class support for

Let your Agent Pay for Blockchain Data

Jayen Harrill — Fri, 20 Feb 2026 18:53:59 +0000

You can use x402 for agents to pay and get access to blockchain data now.

There’s no clean way for agents to access onchain data without API keys, accounts, or billing friction. Until now.

With x402, agents can pay per request using stablecoins over HTTP, wallet in, data out.

https://goldrush.dev/blog/goldrush-x402-blockchain-data-for-agents/