Reliable uptime is essential for any node operator. When nodes stay online and responsive, they help keep the network running smoothly and ensure operators receive the rewards they earn.

In many platforms, uptime is tracked in private databases controlled by the platform itself. This works, but it requires operators to trust that the internal system records everything correctly.

LFG introduces a different approach. Instead of relying only on internal records, uptime data is committed onchain and can be independently verified by anyone.

This article explains how the system works and how operators can confirm that their node uptime has been recorded correctly.

 

Why Move Uptime Tracking Onchain

Traditional monitoring systems store uptime data in centralized databases. While this is common practice, it means operators must rely on the platform to maintain accurate records.

LFG’s new system reduces this dependency by publishing a verifiable record of uptime data on the blockchain.

This provides several benefits:

  • Historical uptime records cannot be changed after they are published
  • Anyone can independently verify the recorded data
  • Reward calculations based on uptime can be audited
  • Operators do not need to rely solely on internal backend systems

In simple terms, the system allows operators to check the data themselves rather than trust that it was recorded correctly.

 

How the System Works

Uptime information collected from nodes goes through several steps before it is published in a verifiable format.

The process looks like this:

Node Operator

   ↓

LFG Aggregator Service

   ↓

Dataset Stored on IPFS

   ↓

Merkle Root Generated

   ↓

Record Submitted to Binance Smart Chain

Here is what happens in practice.

Nodes send uptime telemetry to LFG services while they operate normally. The backend system collects this information and groups it into hourly datasets.

Each dataset is then stored on IPFS, a distributed storage network that keeps files available across multiple nodes rather than on a single server.

After the dataset is created, a cryptographic fingerprint of that dataset is generated and submitted to the blockchain. This fingerprint allows the dataset to be verified later.

 

How Uptime Data Is Stored

Every hour, the system creates a dataset containing the uptime information for nodes during that time period.

Each entry includes details such as:

  • Slug
  • NodeID
  • UptimeAmount

The dataset is uploaded to IPFS.

IPFS returns a CID, or Content Identifier. This is a unique reference to the file. If the file changes in any way, its CID also changes. This ensures that the stored dataset cannot be secretly modified.

To make sure the data stays available, the dataset is pinned within the LFG node network.

The dataset itself is not written directly to the blockchain. Instead, a smaller cryptographic summary of the dataset is recorded.

What Is a Merkle Tree?

To record large datasets efficiently, LFG uses a structure called a Merkle tree.

A Merkle tree is a method used in many blockchain systems to summarize large amounts of data with a single cryptographic value.

You can think of it like a fingerprint for the entire dataset.

Each entry in the dataset is first converted into a hash, which is a unique digital signature. These hashes are then combined step by step until only one final value remains. This value is called the Merkle root.

The key property of this system is that any change to the data will produce a completely different root.

This makes it possible to confirm that the dataset has not been altered.

Only three pieces of information are stored onchain:

  • the Merkle root
  • the dataset’s IPFS CID
  • the timestamp of the submission

This keeps blockchain storage small while still allowing the full dataset to be verified.

 

What Gets Recorded Onchain

When a dataset is published, the LFG smart contract records several details on the Binance Smart Chain:

  • the Merkle root
  • the IPFS CID
  • the timestamp
  • the block number

The system also creates an event on the blockchain that publicly records the submission.

Because blockchain records cannot be changed after they are confirmed, this ensures that historical uptime data remains permanent and verifiable.

 

How Uptime Verification Works

The verification system allows anyone to confirm that a node’s uptime entry exists in the official dataset.

The process works in several steps.

First, the dataset is downloaded from IPFS using the CID recorded on the blockchain.

Next, a verification tool rebuilds the Merkle tree from that dataset.

The user then enters the relevant node information, such as:

  • submission ID
  • project or workload name
  • node ID
  • reported uptime value

The tool generates a Merkle proof, which is a small set of data used to show that a specific entry belongs to the dataset.

This proof is sent to the smart contract. The contract checks whether the proof matches the Merkle root stored onchain.

If everything matches, the verification succeeds. This confirms that the node’s uptime entry exists in the official dataset.

 

Verifying Uptime from the Node Dashboard

LFG also makes this process accessible through the Node Dashboard.

You can check your own node with the LFG uptime verification tool. For a step-by-step walkthrough, see How to Verify Your Node Uptime.

Operators can search for their node, view uptime charts, and click Verify Uptime Onchain.

The dashboard provides:

  • a link to the IPFS dataset
  • a BSCScan transaction link
  • instructions for manual verification

Operators can verify both recent uptime data and historical records through the dashboard.

 

What a Successful Verification Means

A successful verification confirms three important things:

  1. The node’s uptime entry exists in the official dataset
  2. The dataset matches the cryptographic record stored on the blockchain
  3. The data has not been modified since it was published

This allows node operators to independently confirm that their uptime has been recorded accurately.

 

Transparent Uptime Records for Node Operators

By publishing uptime datasets onchain and allowing cryptographic verification, LFG introduces a more transparent approach to infrastructure monitoring.

Instead of relying entirely on internal systems, node operators can confirm their uptime records using publicly verifiable data.

As decentralized infrastructure grows, systems like this help ensure that operational metrics such as uptime remain transparent, auditable, and trustworthy for everyone participating in the network.


 

Was this article helpful?