App Integration

Choose the integration that matches your app’s needs and connect through a Flashblocks-aware RPC endpoint.

Use case	Recommended approach	Documentation
Apps needing instant UX	Flashblocks-aware RPC with the pending tag.	API Reference
Infrastructure providers	Host Flashblocks-aware RPC nodes.	Enable Flashblocks
Standard apps	Continue using regular RPCs.	JSON-RPC API Reference

Tip

Avoid hard dependencies on the WebSocket stream. RPC behavior is stable and falls back automatically to regular blocks if Flashblocks become unavailable.

RPC endpoints

For HTTP and WebSocket endpoint URLs, see the Flashblocks API reference. Public endpoints are rate-limited; for production, route through a Flashblocks-enabled provider such as Alchemy, QuickNode, or dRPC.

Performance characteristics

Metric	Value
Flashblock build time (P50)	~10ms
Preconfirmation latency	~200ms
Full block time	2 seconds
Flashblocks per block	10
Reorg rate	< 0.1%

Gas and transaction sizing

The gas budget is cumulative, not per-Flashblock. Each Flashblock unlocks an additional 1/10 of the total block gas:

Flashblock	Cumulative gas available
1	1/10 of block limit (~40M gas)
2	2/10 of block limit (~80M gas)
3	3/10 of block limit (~120M gas)
…	…
10	Full block limit (~400M gas)

Tip

Unused gas carries forward. If Flashblock 1 only uses 0.3/10 of the budget, Flashblock 2 can use up to 1.7/10 (the cumulative 2/10 limit minus what was already consumed).

Implications for large transactions:

• In practice, gas size is rarely the limiting factor. Base’s per-transaction gas maximum of 16,777,216 gas (~16.7M) is already below Flashblock 1’s ~40M budget, so any valid transaction qualifies for the first Flashblock on size alone.
• Inclusion timing is governed primarily by priority fee relative to others competing in the same 200ms window, not by transaction size.

Reliability and fallback

Base targets a < 0.1% Flashblock reorg rate — the share of preconfirmations that were streamed but missed inclusion in the final block. This is rare, but apps should plan for it.

Caution

Build in fallback logic. Treat preconfirmations as strong signals, not guarantees. For critical operations, confirm against finalized block data. Live reorg metrics are at base.org/stats.

If Flashblocks become unavailable, the sequencer keeps running and confirmation falls back to standard 2-second blocks. Apps should handle both modes.

Library examples

A Flashblocks-aware RPC endpoint is required to use Flashblocks with these libraries.

Wagmi

To use Flashblocks with Wagmi, set the basePreconf chain in the Wagmi config (see config.ts).

Example.tsx

import { useSendTransaction, useWaitForTransactionReceipt } from "wagmi";

function SendTransaction() {
  const { data: hash, sendTransaction } = useSendTransaction();
  const { data: receipt } = useWaitForTransactionReceipt({ hash });

  return (
    <div>
      <button
        onClick={() => sendTransaction({
          to: "0x...",
          value: parseEther('0.0001'),
        })}
      >
        Send Transaction
      </button>
      {hash && <div>Hash: {hash}</div>}
      {receipt && <div>Included on block number: {receipt.blockNumber}</div>}
    </div>
  )
}

App.tsx

import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { WagmiProvider, useAccount } from 'wagmi'
import { config } from './config'
import { Example } from './Example'

const queryClient = new QueryClient()

function App() {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        <Example />
      </QueryClientProvider>
    </WagmiProvider>
  )
}

config.ts

import { createConfig, http } from "wagmi";
import { baseSepoliaPreconf } from "wagmi/chains";
import { baseAccount } from "wagmi/connectors";

export const config = createConfig({
  chains: [baseSepoliaPreconf],
  connectors: [baseAccount()],
  transports: {
    [baseSepoliaPreconf.id]: http(),
  },
});

Viem

import { createWalletClient, http, parseEther, publicActions } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepoliaPreconf } from "viem/chains";

// Create client with the Flashblocks-aware chain.
const account = privateKeyToAccount(`0x${process.env.PRIVATE_KEY}`);
const client = createWalletClient({
  account,
  chain: baseSepoliaPreconf,
  transport: http(),
})
  .extend(publicActions);

const submissionTime = new Date();
console.log(`Submitting transaction at: ${submissionTime.toISOString()}`);

// Send transaction.
const hash = await client.sendTransaction({
  to: "0x...",
  value: parseEther('0.0001'),
});
console.log(`Transaction hash: ${hash}`);

// Wait for transaction to be included.
const receipt = await client.waitForTransactionReceipt({ hash });
const confirmTime = new Date();

console.log(`Transaction included at: ${confirmTime.toISOString()}`);
console.log(`Time difference: ${confirmTime - submissionTime}ms`);

Ethers

  const providerA = new ethers.JsonRpcProvider(
    "https://sepolia.base.org"
  );

  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, providerA);

  try {
    // Create a simple transaction (sending 0.001 ETH to a random address)
    const tx = {
      to: "<SOME ADDRESS>",
      value: ethers.parseEther("0.0000001"),
    };

    // Submit transaction
    const submissionTime = new Date();
    const transaction = await wallet.sendTransaction(tx);

    console.log(`Submitting transaction at: ${submissionTime.toISOString()}`);
    console.log(`Transaction hash: ${transaction.hash}`);

    await transaction.wait(0); // Make sure to set the confirmation count to 0

    console.log("Transaction confirmed");
    const confirmationTime = new Date();
    console.log(`Transaction confirmed at: ${confirmationTime.toISOString()}`);
    console.log(`Time difference: ${confirmationTime - submissionTime}ms`);
  }

Confirmation times against this endpoint should be substantially lower than the standard RPC.

Support

For feedback, support, or questions about Flashblocks, reach the team in the #developer-chat channel on the Base Discord.