Meet Shred API. Built for speed.

Sam Battenally

31 Jul 2025 • 4 min read

Latency places a massive limit on what builders can actually create onchain. High latency introduces extra friction for users, restricts the ability to deliver real-time updates, and makes it impossible to build apps that feel truly responsive.

Today, dApps are built around these constraints. They shape both the user experience and the features that developers can deliver.

Building onchain apps is a far better experience than it was a couple years ago. EVM tooling has come a long way. Tools like viem, wagmi, Foundry, Tenderly, and wallet SDKs like Dynamic and Privy have made building great apps much easier. But no tool can help builders overcome the core barrier: the infrastructure itself.

Over time, builders have found creative ways to work around these limitations. But what if you had no limits?

RISE and the Shreds API unlock real-time performance for dApps, with a simple developer experience.

Closing the Gap Permanently

This hits at the core of why we’re so excited about Shreds. Shreds offer real-time continuous execution. Rather than waiting for an entire block to complete before offering a user a confirmation or updating the global state in your app, you can now do it in real time. You can see the block constructing as it happens, every transaction, every state update, completely public and entirely real time.

We’re not talking about an incremental improvement to chain speed. We’re talking about closing the gap between modern Web2 technology and crypto. With Shreds, building feels extremely familiar to traditional Web2 developers and allows builders to create apps that previously didn’t work onchain. You send a request, you get a response. Someone updates state, you subscribe and allow users to see updates immediately.

We’ve been working towards this as an industry, and we’re excited to share that the sea is no longer parted. We’ve closed the gap for good.

Show Me the Code, or It Didn’t Happen

You’re a dev and want to use Shreds? It’s super simple.

Step one: jump into our Shred Toolkit and check out the Quickstart Guide.

But here’s the TLDR:

There are three key touchpoints for leveraging Shreds:

Sending instant transactions
Streaming global real-time state
Fetching real-time state

Sending Instant Transaction

Sending instant transactions on RISE leverages eip-7966, which introduces a new RPC method, eth_sendRawTransactionSync, a blocking method that returns the receipt immediately and requires no receipt polling. Why is this important? On RISE, specifically, this method halves the latency of transaction confirmations.

eip-7966 is not widely adopted yet, however we believe it will be. In the meantime, the RISE team built a shred module that allow you to use it alongside viem.

The example below uses the shreds npm module alongside viem to send a transaction and get a receipt in one http request.

import { sendTransactionSync } from 'shreds/viem'
 
// Traditional async pattern (not needed with shreds)
// const hash = await client.sendTransaction(tx)
// const receipt = await client.waitForTransactionReceipt({ hash })
 
// shreds synchronous pattern
const receipt = await sendTransactionSync(client, tx)
// Transaction already confirmed with receipt!

Streaming Global State

With Shreds, we also introduce a new subscription type to eth_subscribe where you can stream global state updates immediately as they are processed by the sequencer. To demonstrate this, let’s take a look at this simple example where we monitor balance changes right as they happen in realtime:

import { createPublicClient, webSocket, formatEther } from 'viem'
import { riseTestnet } from 'viem/chains'
import { watchShreds } from 'shreds/viem'

const wsClient = createPublicClient({
  chain: riseTestnet,
  transport: webSocket()
})

const address1 = '0xdeadbeef...'
const address2 = '0xbeefdead...'

// Watch for balance changes
const unwatch = watchShreds(wsClient, {
  onShred: (shred) => {
    for (const stateChange of shred.stateChanges) {
      // Check if this is one of our monitored addresses
      if (stateChange.address === address1 || stateChange.address === address2) {
        console.log(`Balance change for ${stateChange.address}:`)
        console.log(`   New balance: ${formatEther(stateChange.balance)} ETH`)
      }
    }
  },
  onError: (error) => {
    console.error('Shred watching error:', error)
  }
})

If you need to listen to events emitted from your contracts in realtime, you don’t need to change a single line in your code. RISE streams down contract logs immediately as they are emitted when you subscribe to them:

// The same watchEvent (and watchContractEvent) method is used. No changes required!
client.watchEvent({
  event: transferEvent,
  address: '0xdeadbeef...',
  onLogs: (logs) => {
    logs.forEach((log) => {
      console.log('Transfer:', log.args.from, '→', log.args.to, log.args.value)
    })
  },
})

Fetching Realtime State

In addition to realtime subscriptions, all other RPC methods that return onchain state is guaranteed to return the latest data. This means that if you call sendRawTransactionSync to send ETH to some address and then getBalance on that address afterwards, you will immediately be able to see the balance change.

Some Exciting Use Cases

DeFi

Currently, the majority of volume for both spot and derivative markets in crypto is still done offchain via CEXs. One of the biggest reasons for this is that offchain order books can provide superior UX and performance in terms of latency and costs.

With Shreds, the potential is there to start building fully onchain CLOBs that can not only match but beat the performance and features of CEXs. From low-latency confirmations on trades to real-time market data updates, this vision can be achieved.

This comes with the added benefit of onchain CLOBs operating in the fully composable EVM, which can potentially unlock a new wave of innovation in terms of new primitives and money legos.

Additionally, with low-latency transactions combined with 7702 and smart wallets, builders can now provide users with seamless UX for interacting with DeFi.

Historically, building fully onchain real-time multiplayer games has been a huge challenge. Builders have always had to choose between being fully onchain and having real-time multiplayer features.

With Shreds on RISE, now you can have both. No longer do you need to maintain a separate server offchain to handle real-time features — you can just do it all onchain. Call game functions and receive receipts immediately, and subscribe to game state changes as they are updated.

This all happens in the client, without having to rely on a backend server, exponentially enhancing both the developer and the user experience.

Start Building with Shreds

Ready to provide a better user experience in your dApp by integrating Shreds? You can get started by installing the official TypeScript client package from npm:

npm install shreds

Or head over to the GitHub repo to learn more: risechain/shred-api.

We’re super excited to see what you’ll build on RISE using the new Shreds API!