Technical proof path

Prove the indexing model before you build on it

EasyLayer is useful when your product needs its own blockchain state service: custom models, focused storage, event history, reorg-aware architecture, and transports for server, desktop, and browser apps.

Custom state, not generic archives

Define the state your product needs: a smart-contract monitor, wallet activity feed, UTXO tracker, balance model, or fee monitor. The service persists your model events instead of forcing your app to store and filter a full blockchain copy.

Focused storage footprint

If you only need one contract, a set of wallets, or a narrow business state, the application database should hold that state and its event history — not terabytes of unrelated chain data.

Reorg-aware architecture

EasyLayer is built around persisted events, rollback, and state restoration. The site should show this as an architecture capability and keep production guarantees tied to tested deployments.

EventStore as source of truth

Model changes are recorded as ordered events. That gives the service a replayable history for historical reads, recovery, and debugging instead of hidden in-memory state.

Transports for real apps

HTTP, WebSocket, IPC, Electron IPC, and browser/shared-worker paths make the same state service usable from backend services, desktop apps, browser extensions, and frontend clients.

Self-hosted control

Run the service on your infrastructure and choose your node/provider. EasyLayer is not a hosted black box; it is a framework for owning the runtime around your blockchain state.

What to validate first

A practical evaluation path

Step 1

Run a package example

Start with the current Bitcoin or EVM crawler docs. Confirm the service starts, persists events, and can answer a query through a transport.

Step 2

Replace the generic model with your own state

Pick one narrow product state. A single contract, a wallet set, or one business event stream is enough to test the value of focused indexing.

Step 3

Check the integration surface

Decide where the state must be consumed: backend service, WebSocket client, desktop app, browser extension, or another process through IPC.

// Your application stores the state it actually needs.
// EasyLayer feeds blocks into the model and persists the emitted events.

const ContractMonitor = {
  modelId: 'contract-monitor',
  state: { transfers: [] },
  sources: {
    async log(ctx) {
      if (ctx.log.address !== TARGET_CONTRACT) return;
      return { txHash: ctx.tx.hash, blockHeight: ctx.block.height };
    },
    async block(ctx) {
      if (!ctx.locals.log?.length) return;
      ctx.applyEvent('TransfersSeen', ctx.block.height, {
        transfers: ctx.locals.log,
      });
    },
  },
};

What is proven on the site today

The current public proof is the codebase, package documentation, architecture explanations, and reference examples. Benchmarks and case studies should be added only after they are measured and reviewed, but the developer can already evaluate the runtime model and integration path.