Building a unified view of cross-chain activity requires indexing Axelar's on-chain contracts across multiple heterogeneous chains and reconciling their disparate event schemas into a single, coherent data model. The core challenge is not simply collecting logs, but normalizing the lifecycle of a General Message Passing (GMP) call or an Interchain Token Service (ITS) transfer—from the source chain's ContractCall event, through Axelar's confirmation and batching logic, to the destination chain's ContractCallApproved or Executed event. Data engineers must design a pipeline that treats each cross-chain operation as a state machine, joining events across chains using the unique commandId or ITS transfer hash, while accounting for chain-specific finality windows and reorg depths that can cause temporary inconsistencies in the unified view.
Indexing and Querying Cross-Chain Activity Across Axelar Contracts
Building a Unified Cross-Chain Data View
A technical guide for data engineers on constructing a coherent, queryable view of cross-chain activity by indexing Axelar's gateway and ITS contracts across heterogeneous chains.
The indexing architecture must handle fundamental differences in chain behavior: probabilistic finality on chains like Ethereum versus deterministic finality on Cosmos SDK chains, variable block times, and distinct RPC reliability profiles. A robust pipeline extracts events from Axelar's gateway and ITS contracts on each connected chain, applies chain-specific confirmation heuristics (e.g., waiting for a configurable number of blocks or a finality gadget signal), and then correlates events into a canonical cross-chain operation record. For ITS, this includes tracking token supply changes across linked chains to detect imbalances that could signal a bridge integrity issue. The event schemas themselves—such as ContractCall, ContractCallWithToken, TokenSent, and Executed—must be mapped to a unified schema that includes source chain, destination chain, payload hash, status, and timestamps at each stage.
Operational teams building these pipelines should implement monitoring on the indexing lag per chain and alert on gaps in commandId sequences that may indicate missed events or a chain RPC outage. Query patterns for compliance and analytics use cases include: reconstructing the complete lifecycle of a specific cross-chain message for auditing, aggregating cross-chain volume by token or application, and identifying messages stuck in a pending state beyond a threshold duration. Chainscore Labs can review an existing indexing pipeline's data integrity, assess its resilience to chain reorganizations and RPC failures, and validate that the unified schema correctly captures all terminal states and error conditions defined by the GMP and ITS protocols.
Indexing Quick Facts
Operational and technical facts for teams building or maintaining indexing pipelines that aggregate cross-chain activity across Axelar's Gateway, GMP, and ITS contracts.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
Event Schema | Contract events on each chain have distinct signatures, topics, and ABI layouts. Gateway, Gas Service, and ITS contracts emit different event sets. | Data engineers, indexer operators | Map canonical event signatures per contract version. Do not assume uniform ABI across chains. |
Finality Windows | Source-chain finality (probabilistic vs. deterministic) affects when an event can be considered irreversible for indexing purposes. | Backend teams, analytics engineers | Implement chain-specific confirmation depth logic before treating a GMP call or ITS transfer as finalized in your pipeline. |
Reorg Handling | A deep reorg on a source chain after Axelar confirmation creates a state discrepancy between indexed data and actual message execution. | Data integrity teams, SREs | Build reorg detection and reconciliation jobs. Validate indexed state against destination-chain execution events. |
Cross-Chain Correlation | Linking a source-chain ContractCall to its destination-chain Executed event requires tracking the message ID across heterogeneous event logs. | Analytics teams, compliance monitors | Use the Axelar message ID as the primary correlation key. Verify that your pipeline correctly handles multi-hop and retry scenarios. |
ITS Supply Tracking | Total supply of an Interchain Token is the sum of balances across all linked chains. Lock/unlock vs. burn/mint modes change supply invariants. | Token issuers, treasury teams, data analysts | Index all ITS token contract events on every linked chain. Reconcile supply invariants based on the token's deployment mode. |
Contract Upgradeability | Axelar Gateway and ITS contracts can be upgraded via governance. Event signatures, storage layouts, or deployment addresses may change. | Indexer operators, integration engineers | Monitor governance proposals and upgrade announcements. Maintain a versioned event schema registry and update ingestion logic proactively. |
RPC Reliability | Indexing across multiple chains multiplies RPC dependency risk. Rate limits, node failures, or inconsistent API behavior cause data gaps. | DevOps teams, data platform engineers | Deploy redundant RPC providers per chain. Implement backfill logic and alert on ingestion lag or gap detection. |
Gas Service Events | Gas payment and refund events on the Axelar Gas Service contract are separate from GMP execution events and must be indexed independently. | Relayer operators, cost analysts | Index Gas Service contracts to track cross-chain fee economics. Correlate gas payments with GMP call success and failure rates. |
The Indexing Surface: Contracts, Events, and Lifecycle
Defining the on-chain event schema and contract lifecycle that form the basis for indexing cross-chain activity.
Building a unified view of cross-chain activity across Axelar's General Message Passing (GMP) and Interchain Token Service (ITS) begins with a precise understanding of the indexing surface: the set of contracts, their emitted events, and the lifecycle of a cross-chain message. This surface is inherently fragmented, spanning the Axelar hub chain, dozens of connected external chains, and distinct contract versions deployed over time. Data engineers must map this landscape to reliably capture message flow, token supply changes, and execution status without gaps or double-counting.
The primary indexing targets are the Axelar Gateway contracts deployed on each connected chain, the ITS token manager and token deployer contracts, and the core protocol contracts on the Axelar mainnet itself. Key events include ContractCall, ContractCallWithToken, and Executed on the Gateways, which bookend the GMP lifecycle, and InterchainTransfer, DeployInterchainToken, and InterchainTokenDeployed on ITS contracts, which track token origin and movement. A critical operational detail is that event signatures and indexing strategies must account for contract upgrades; a Gateway upgrade on a source chain will change its address, requiring indexers to maintain a versioned registry of canonical deployment addresses per chain.
The lifecycle of a cross-chain message is not a single atomic event but a sequence of discrete on-chain state transitions across multiple chains. An indexer must correlate a ContractCall event on the source chain with a CallApproved event on the Axelar hub, followed by an Executed event on the destination chain. Failure modes, such as a reverted execution on the destination, are signaled by specific event payloads that must be parsed to distinguish a temporary gas issue from a permanent application-level error. For ITS, supply reconciliation requires tracking both the lock/burn event on the source chain and the corresponding mint/unlock event on the destination chain, ensuring the aggregate supply across all linked chains remains consistent. Chainscore Labs can review an indexing pipeline's event coverage, contract registry management, and lifecycle state machine logic to identify gaps that could lead to inaccurate cross-chain balances or missed message failures.
Stakeholder Impact
Data Pipeline Design
Indexing Axelar's cross-chain activity requires ingesting heterogeneous event schemas from the Gateway, Gas Receiver, and ITS contracts across multiple EVM chains simultaneously.
Key Actions:
- Normalize
ContractCall,ContractCallWithToken, andExecutedevents into a unified message lifecycle schema. - Account for chain-specific block times and reorg depths when designing your ingestion pipeline. A finalized block on one chain may still be subject to reorg on another.
- Implement idempotent event processing to handle chain reorganizations gracefully.
Chainscore Angle: An indexing pipeline review can identify gaps in your event schema normalization, finality tracking logic, and reorg handling before they corrupt downstream analytics or compliance reporting.
Indexing Pipeline Architecture
Designing a reliable indexing pipeline for Axelar's General Message Passing (GMP) and Interchain Token Service (ITS) requires handling heterogeneous finality, event schema consistency, and chain-specific reorg windows.
Unified Event Schema Normalization
Axelar's gateway and ITS contracts emit events on multiple EVM and Cosmos chains. A robust pipeline must normalize these heterogeneous schemas into a unified internal model. Key events include ContractCall, Executed, TokenSent, and TokenDeployed. Indexers must map chain-specific log addresses and topic hashes to a canonical representation, handling ABI variations across contract versions. Chainscore Labs can review your event ingestion logic for schema completeness and edge-case handling.
Finality Tracking and Reorg Handling
Indexers must not treat a block as final until it passes the source chain's specific safety threshold. Probabilistic finality on chains like Polygon requires waiting for a sufficient number of block confirmations, while deterministic finality on Cosmos chains requires tracking the Axelar validator set's confirmation. Your pipeline must implement a per-chain confirmation count strategy and a reorg detection mechanism that can invalidate and re-process affected blocks. Chainscore assesses your finality gap logic to prevent double-counting or missed messages.
Cross-Chain Message Lifecycle State Machine
A GMP call transitions through distinct states: source_chain_confirmed, axelar_validated, destination_executed, or destination_failed. Your indexing pipeline must reconstruct this lifecycle by correlating events across independent ledgers. This requires a state machine that joins the source-chain ContractCall event with the destination-chain Executed event using the unique commandId. Implement idempotency keys to handle out-of-order event delivery. Chainscore can audit your state transition logic for correctness under network partition scenarios.
ITS Supply Reconciliation Across Chains
For ITS tokens using the lock/unlock or burn/mint model, total supply integrity requires reconciling balances across all linked chains. Your indexer must track TokenSent and TokenReceived events to maintain a real-time view of token supply distribution. A mismatch indicates a potential bridge exploit, a stuck message, or an indexing bug. Implement automated supply invariant checks that alert on any discrepancy. Chainscore provides supply reconciliation audits to ensure your data layer accurately reflects on-chain state.
Relayer and Gas Payment Attribution
Understanding the economics of cross-chain execution requires indexing gas payment and refund events. The pipeline should attribute GasPaidForContractCall events to specific messages and track relayer addresses. This data is critical for monitoring relayer profitability, detecting gas-griefing attacks, and building accurate cost dashboards for your application. Chainscore can help design a data model that correctly links gas payments to the originating GMP call for financial reporting and operational monitoring.
Query Patterns for Compliance and Analytics
A well-architected pipeline enables efficient querying for compliance screening and volume analytics. Design your database schema to support queries like 'all messages from a sanctioned address' or 'total USD volume bridged via ITS in the last 24 hours'. This requires indexing token prices at the time of transfer and maintaining an address-entity mapping. Chainscore Labs can review your data model for query performance and assess its ability to support regulatory reporting requirements.
Data Integrity and Pipeline Risks
Evaluates failure modes and operational risks for data pipelines that ingest cross-chain activity from Axelar contracts, focusing on event schema stability, chain-specific reorg handling, and query accuracy.
| Risk | Failure mode | Who is affected | Mitigation |
|---|---|---|---|
Event signature mismatch | A gateway or ITS contract upgrade changes event topics or indexed parameters, causing the indexer to silently miss new messages. | Data engineers, analytics teams, compliance monitors | Pin event signatures to specific contract versions and implement schema validation alerts on ingestion. |
Cross-chain finality reorg | A source chain experiences a deep reorg after Axelar validators confirm the message. The indexer records a transaction that is later orphaned on the source chain. | Exchange operations, bridge relayers, risk teams | Implement a confirmation threshold buffer per chain and reconcile indexed events against canonical chain state after N blocks. |
RPC provider inconsistency | A load-balanced RPC endpoint returns different log results or misses events due to node desync, causing gaps in the indexed history. | Backend developers, SREs | Use batched, paginated log queries with block-range overlap and verify response integrity across multiple providers. |
ITS supply reconciliation gap | The sum of token supplies across all linked chains diverges from the expected invariant due to a missed burn or mint event on one chain. | Token issuers, DeFi protocol teams, treasury managers | Implement a cross-chain supply invariant check that alerts on any non-zero drift across registered ITS tokens. |
Contract upgrade race condition | The indexer processes blocks near a contract upgrade boundary and applies the old ABI to new events, corrupting the decoded data. | Data teams, application developers | Monitor proxy admin or governance contracts for upgrade events and trigger an immediate ABI refresh with a processing halt window. |
Gas and relayer event omission | The gas receiver or relayer contracts emit events that the indexer ignores, leading to incomplete cost attribution for cross-chain messages. | Protocol economists, relayer operators | Expand the indexing schema to include all auxiliary contract events and join them with GMP call traces for full cost accounting. |
Query pattern performance degradation | As indexed data grows, queries that join GMP calls across multiple chains time out or return partial results under load. | Analytics teams, API developers | Pre-aggregate cross-chain message statuses into materialized views and partition data by source chain and block month. |
Indexer Implementation Checklist
A practical checklist for data engineers and backend teams building an indexer to unify cross-chain activity across Axelar's Gateway, Gas Receiver, and ITS contracts. Each item identifies a critical implementation step, explains why it matters for data integrity, and specifies the signal or artifact that confirms readiness.
Axelar's contracts emit events on chains with different consensus mechanisms (probabilistic finality on Ethereum vs. deterministic on Cosmos chains). Your indexer must not treat a block confirmation as final until the Axelar network confirms it.
Why it matters: Indexing a log from a block that is later reorganized will create phantom messages, corrupting volume metrics, supply reconciliation, and compliance reports.
Readiness signal: The ingestion pipeline applies a chain-specific confirmation depth before processing any ContractCall or TokenSent event. A separate process monitors for deep reorgs and emits compensating events to correct the indexed state.
Canonical Resources
Use these primary resources to build and validate an indexer for Axelar GMP, Interchain Token Service, gateway, gas service, and cross-chain execution activity. Treat contract ABIs, official docs, and live message explorers as complementary sources rather than interchangeable truth.
Looking to build on a specific blockchain?
We build smart contracts, DeFi applications, wallets, tokenization platforms, and blockchain infrastructure across the major ecosystems teams choose today. That includes Ethereum, Arbitrum, Optimism, Polygon, Avalanche, Solana, Sui, Aptos, Hedera, Stellar, and NEAR, with support for additional EVM and non-EVM networks based on your product requirements.
EVM ecosystems
- Ethereum
- Arbitrum
- Optimism
- Polygon
- Avalanche
- Cronos
Non-EVM ecosystems
- Solana
- Sui
- Aptos
- Hedera
- Stellar
- NEAR
Additional ecosystems
- Polkadot
- Cosmos
- TON
- Cardano
- Algorand
- Tempo
Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.
Frequently Asked Questions
Common questions from data engineers and backend teams building a unified view of cross-chain message flow, volume, status, and ITS supply across Axelar contracts.
To build a complete picture of General Message Passing (GMP) activity, you must index events from the Axelar Gateway contracts on every chain of interest, as well as the Axelar network's own contracts.
Primary events to index:
ContractCall: Emitted on the source chain's Gateway when a cross-chain message is initiated. This is your starting event for tracking outbound volume.ContractCallApproved: Emitted on the destination chain's Gateway after the Axelar validator set has confirmed the source-chain transaction and approved execution. This is the critical event for tracking inbound execution and finality.Executed: Emitted on the destination chain's Gateway after the_executecall to the destination contract completes. Monitoring this event is essential to distinguish between approved messages and successfully executed ones.
Why this matters: Indexing only one side of the flow leaves you blind to messages that are approved but fail execution, or messages that are stuck in the relayer queue. A complete index requires correlating ContractCall events on the source chain with ContractCallApproved and Executed events on the destination chain using the unique commandId.
Delivering blockchain solutions for 5+ years.
We have partnered with 50+ leading DeFi protocols, NFT ecosystems, and fintech innovators to build secure, scalable, and capital-efficient blockchain products.
Selected Partners & Clients
“I've been working with Chainscore Labs for last 3+ years, they've consistently delivered with strong ownership across multiple projects. The team is reliable and detail-oriented.”
How to get started?
If you're looking for blockchain integration, ChainScore Labs has 5+ years of experience helping teams build and integrate exchanges, wallets, smart contracts, tokenization solutions, and protocol-connected products, we can help you choose the right path, integrate securely, and get to production faster. Our team consists of experienced blockchain developers and architects who can help you with your blockchain integration needs.
Exploration & Strategy
Define your product goals and choose the right blockchain architecture for your use case.
Architecture & Design
Design the smart contracts, tokenomics, and security parameters of your system.
Development & Integration
Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.
Security & Launch
Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.
Discover our
blockchain development services.
We build production-grade blockchain solutions for top-tier projects across DeFi and Web3.
Need a blockchain engineering team?
Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.