Sentio
bg

From Transaction to Dashboard: A Developer’s Guide to Monitoring IOTA

9 min read
Sep 3, 2025

If you're here, you've probably already decided to build on IOTA. You were drawn in by its powerful Move VM, its focus on real-world assets, and its incredible performance. But now your smart contracts are deployed, and you're facing the big question: what's actually happening inside them?

When you're dealing with everything from complex DeFi protocols to enterprise-grade logistics, just "shipping it" isn't enough. You need to see everything—performance bottlenecks, user activity, and especially that one weird transaction that failed for no apparent reason.

This guide is your practical walkthrough for getting that deep visibility. We'll show you how to use Sentio, a monitoring platform designed specifically for Move-based chains like IOTA, to go from flying blind to having a complete mission control for your DApp.

What Makes IOTA Special? A Quick Refresher

Before we dive into the "how," let's quickly recap the "why." IOTA isn't just another Layer 1; its new architecture combines several key innovations that make it unique.

  • Move VM at the Core: IOTA utilizes the Move VM for exceptionally secure and efficient Layer 1 smart contracts. Its design treats digital assets like physical objects, inherently preventing common token vulnerabilities.
  • Lightning-Fast Consensus: The network’s delegated Proof-of-Stake (dPoS) system achieves finality in under a second and handles over 50,000 transactions per second. With up to 150 validator slots, it’s built for genuine decentralization.
  • Smart Tokenomics: IOTA has a balanced economic model designed for sustainability. It mints new tokens to reward participants and burns transaction fees to counteract inflation.
  • The Best of Both Worlds (Dual-Layer): A dual-layer system gives developers ultimate flexibility. They can use high-performance Move on Layer 1 or familiar EVM-compatible chains on Layer 2 without compromise.
  • A Focus on the Real World: IOTA is dedicated to enterprise adoption with tangible projects like the Trade Worldwide Information Network (TWIN). It partners with major organizations to tokenize real-world assets like global trade.

Whether you're building for DeFi or digitizing trade finance, IOTA provides the foundation. Now, let's make sure you have the tools to monitor everything you build on it.

1. First, Let's Get the Data: Indexing IOTA's Move Architecture

Before you can analyze anything, you need a clean, reliable stream of data. IOTA's Move-based contracts generate a ton of it—object changes, events, resource transfers—and you need a way to capture it all without the headache of running your own infrastructure.

Sentio’s indexing engine is purpose-built for Move. It understands objects, resources, and events right out of the box.

Let's see this in action with a real-world example: building a dashboard to monitor IOTA's validators. We want to track every time someone stakes, and we also want to get performance reports for each validator at the end of an epoch.

It only takes a few lines to start listening to the core validator contracts:

import { validator, validator_set } from '@sentio/sdk/iota/builtin/0x3'
import { IotaNetwork } from '@sentio/sdk/iota'
 
// First, let's watch for anyone staking with a validator
validator.bind({ 
  network: IotaNetwork.MAIN_NET,
  startCheckpoint: 1000000n 
}).onEventStakingRequestEvent(
 async (evt, ctx) => {
 // We get fully-typed data right from the event
 const { validator_address, staker_address, amount } = evt.data_decoded;
 const scaledAmount = amount.scaleDown(9); // IOTA uses 9 decimals
 
 // Log the raw event for later analysis
    ctx.eventLogger.emit('stake_action', {
      action: 'stake',
      amount: scaledAmount,
      validator: validator_address,
      delegator: staker_address,
    });
 
 // And update some real-time metrics for our dashboard
    ctx.meter.Counter('total_stakes').add(1, { validator: validator_address });
    ctx.meter.Counter('staking_volume').add(scaledAmount, { validator: validator_address });
  },
  { allEvents: true } // Process events from all validator objects
);
 
// Next, let's grab the performance report for each validator every epoch
validator_set.bind({ network: IotaNetwork.MAIN_NET }).onEventValidatorEpochInfoEventV1(
 async (evt, ctx) => {
 const { validator_address, stake, voting_power, performance_score } = evt.data_decoded;
 
 // We'll use Gauge metrics here since these values can go up or down
    ctx.meter.Gauge('validator_stake').record(stake.scaleDown(9), { validator: validator_address });
    ctx.meter.Gauge('validator_voting_power').record(voting_power, { validator: validator_address });
    ctx.meter.Gauge('validator_performance_score').record(performance_score, { validator: validator_address });
  },
  { allEvents: true }
);

Just like that, we're pulling in crucial network health data. You can find the Just like that, we're pulling in crucial network health data. You can find the full source code on GitHub. The same pattern works for any DApp you build—DeFi, gaming, enterprise, you name it.

2. A Saner Way to Code: The Type-Safe SDK

Working with raw blockchain data can feel like a guessing game. Is that amount field a u64 or a u128? Did I spell that event name correctly?

Sentio’s SDK is designed to eliminate that guesswork. When you point it at your Move module's ABI, it automatically generates TypeScript interfaces for all your events, functions, and resources. This means you get full autocompletion in your IDE and the compiler will catch your typos, not your users.

// Imagine this is from your own custom DEX module on IOTA
import { dex } from './types/iota/0xYourPackage.dex'
 
dex.bind({
  network: IotaNetwork.MAIN_NET,
  startCheckpoint: 1000000n
}).onEventSwapEvent(async (evt, ctx) => {
 // No more guesswork! The `evt.data_decoded` object is fully typed.
 const { amount_in, amount_out, user } = evt.data_decoded;
 // Your IDE knows the type of amount_in, amount_out, and user.
});

And depending on what you need to track, Sentio gives you a few different tools for the job:

  • IotaObjectProcessor: Need to watch one specific object? Use this.
  • IotaObjectTypeProcessor: Want to track every object of a certain type, like all NFT listings across the entire network? This is your go-to.
  • IotaAddressProcessor: Want to see all the transactions and objects associated with a specific address? Here you go.

3. What Can You Do With the Data? Turning It Into Insights

Collecting data is one thing; making it useful is another. Sentio gives you several ways to shape your indexed data into actionable insights.

  • Metrics: These are your numbers, the vital signs of your DApp. They're perfect for tracking things like transaction volume, daily active users, or the TVL in your protocol. Metrics power dashboards and alerts, giving you a high-level view at a glance.
// Examples of different metrics you could track
ctx.meter.Counter('user_transactions').add(1, { user_type: 'enterprise' });
ctx.meter.Gauge('active_objects').record(object_count);
  • Event Logs: This is the detailed story of your DApp. Think of it as a perfectly structured, human-readable log of everything that happens. It's invaluable for debugging or analyzing specific user journeys.
// Log rich data for every validator epoch report
ctx.eventLogger.emit('validator_epoch_info', {
  validator: validator_address,
  stake,
  voting_power,
  performance_score
});
  • Entities: This lets you store and query the relationships between things in your DApp. By using entity store, you now have the capability to organize your data based on a predefined schema. This structured data can be accessed during the processor's execution and can also be retrieved using our SQL and GraphQL APIs.

4. Your Mission Control: The Data Studio

You've done the hard work of collecting and processing your data. Now for the fun part: seeing it come to life. You shouldn't need a data science degree or a front-end team to build a powerful dashboard.

With Sentio's Data Studio, any metric you created in your code instantly becomes available to visualize. Better yet, you can write SQL to query your Event Logs and build incredibly detailed analytics.

Let's take our validator data from Step 1 and ask some real questions:

"Which validators are earning the most?"

-- Top performing validators by rewards
SELECT 
  validator,
 SUM(pool_staking_reward) as total_rewards
FROM validator_epoch_info 
WHERE timestamp >= NOW() - INTERVAL '30 days'
GROUP BY validator
ORDER BY total_rewards DESC
LIMIT 20;

"Validatos’ staking activities"

SELECT
  DATE_TRUNC('hour', timestamp) AS hour_timestamp,
 SUM(CASE WHEN action = 'stake' THEN amount ELSE 0 END) as staked,
 SUM(CASE WHEN action = 'unstake' THEN ABS(amount) ELSE 0 END) as unstaked
FROM `stake_action`
WHERE validator = $validator
 AND timestamp >= CURRENT_TIMESTAMP() - INTERVAL '7' DAY
GROUP BY hour_timestamp
ORDER BY hour_timestamp

You can build dashboards to answer almost any question, from user retention in your DeFi app to asset flows in a logistics platform. And, you can set up alerts to ping you on Slack or Telegram if something looks off, like a validator's performance suddenly dropping.

image

You can explore the project on the live validator dashboard.

Beyond Your Custom Data: Ready-to-Use IOTA Datasets

But here's where it gets even better: you don't have to build everything from scratch. Sentio provides a comprehensive set of IOTA datasets right out of the box through the Schema Panel:

  • balance_changes: Track how token balances shift across addresses
  • events: Access all emitted events from smart contracts
  • move_calls: See every function call made to Move modules
  • object_changes: Monitor state changes to IOTA objects
  • transactions: Complete transaction data with full context

These aren't just raw blockchain dumps—they're clean, structured datasets that Sentio maintains and continuously updates. Think of them as your analytics foundation, ready to query without any preprocessing headaches.

5. Why Did My Transaction Fail? Debugging Move with a Tracer

We’ve all been there. A transaction mysteriously fails, and you're left staring at a transaction hash, wondering what went wrong.

Sentio's Transaction Tracer is like a super-powered debugger for your DApp. It gives you a complete, step-by-step replay of the entire transaction, showing you:

  • The Full Call Stack: Trace the flow of logic through every function call, even across different modules.
  • Gas Usage Analysis: The debugger shows resource consumption patterns and state changes, helping you identify performance bottlenecks.

This turns debugging from a frustrating guessing game into a precise, analytical process.

image

image

6. Dedicated RPC Nodes

Sentio provides high-performance RPC endpoints for both IOTA mainnet and testnet, giving you fast, reliable access to query object states, read historical data, and subscribe to real-time object changes—all without the hassle of building and maintaining your own nodes.

What You Get from Sentio RPC

  • Complete Historical Data: Every transaction, every state change, from day one. Whether you're debugging something that happened last week or analyzing trends over months, it's all there.
  • Real-Time Monitoring: Built-in dashboards show you exactly what's happening. Request latency, throughput, error rates—you'll spot issues before your users do.
  • Always Available: Distributed infrastructure means your calls get through, even when things get busy. No more wondering if your RPC provider is the bottleneck.

Two Options to Fit Your Needs

Sentio offers two types of RPC nodes:

  • Public Nodes: Free access with rate limits—perfect for development and testing.
  • Mainnet: https://rpc.sentio.xyz/iota
  • Testnet: https://rpc.sentio.xyz/iota-testnet
  • Archive Nodes: Pay-as-you-go pricing with full historical access and no rate limits—ideal for production applications that need complete blockchain data.

Ready to Build on IOTA?

IOTA's Move VM and dual-layer architecture open up a world of possibilities. With the right tools, you can focus on building innovative applications instead of wrestling with observability challenges. Sentio gives you the complete monitoring stack you need to build with confidence.