Soroban Smart Contracts Explorer

Soroban Pro

Premium smart contract explorer with decoded data, real-time event streaming, and AI-powered explanations for Stellar's Soroban platform.

Introduction

The Soroban Smart Contracts Explorer is a premium tool designed for Web3 developers, startups, and auditors who need deep visibility into Soroban smart contracts on the Stellar network. Unlike basic block explorers, our tool provides decoded contract data, making it easy to understand what contracts are doing without manually parsing XDR-encoded data.

</>

Decoded Calls

Human-readable function calls and parameters

{ }

Storage Viewer

Browse contract state and data

~>

Event Stream

Real-time contract event monitoring

AI

AI Explanations

Plain-English contract analysis

Dashboard

The Contracts Explorer dashboard at /contracts provides a centralized interface for exploring Soroban smart contracts.

Dashboard Features

  • Contract Search - Search by contract ID, name, or deployer address
  • Recent Contracts - View recently deployed or active contracts
  • Contract Overview - Quick stats including total calls, storage size, and events
  • Analytics - Gas usage trends, error rates, and call frequency

Getting Started

  1. Navigate to /contracts
  2. Enter a contract ID in the search bar (e.g., CDLZ...XYZ)
  3. Explore decoded calls, storage, events, and analytics

Subscription Tiers

Soroban Pro features are available across different subscription tiers, each designed for specific use cases.

FeatureFreeDeveloper
$25/mo
Team
$99/mo
AuditorEnterprise
Contracts/month1050UnlimitedUnlimitedUnlimited
Call history retention7 days30 days90 daysFullFull
AI explanations-50/mo500/moUnlimitedUnlimited
Export (CSV/JSON)-
Real-time event streaming--
Version comparison-
API access-

</>Decoded Calls

Soroban smart contract calls are encoded in XDR (External Data Representation) format, making them difficult to read in their raw form. The Decoded Calls feature automatically parses and decodes this data into human-readable format.

What Gets Decoded

Function Calls

  • - Function name (e.g., transfer, mint)
  • - Parameter names and values
  • - Parameter types (Address, i128, Symbol, etc.)
  • - Return values with type information

Transaction Context

  • - Caller/source account
  • - Timestamp and ledger sequence
  • - Gas consumed (in stroops)
  • - Success/failure status with error codes

Example: Raw vs Decoded

Raw XDR (unreadable):

AAAAAgAAAADo...base64_encoded_xdr_data...AAAAAAAAAA==

Decoded (human-readable):

{
  "function": "transfer",
  "parameters": {
    "from": "GABC...XYZ",
    "to": "GDEF...UVW",
    "amount": 1000000000  // 100 tokens (7 decimals)
  },
  "result": {
    "type": "void",
    "success": true
  },
  "gas_used": 234567,
  "timestamp": "2026-02-13T10:30:00Z"
}

Call History Table

The Call History view displays all invocations of a contract with the following columns:

ColumnDescription
TimestampWhen the call was executed
FunctionDecoded function name
CallerSource account address (truncated)
ParametersDecoded input parameters
StatusSuccess (green) or Failed (red) with error code
GasGas consumed in stroops

Filtering Calls

Use the filter options to narrow down the call history:

  • Function name - Filter by specific function (e.g., transfer)
  • Caller address - Show calls from a specific account
  • Status - Filter by success or failed calls only
  • Date range - Specify start and end dates
  • Gas range - Filter by minimum/maximum gas consumed

{ }Storage Viewer

The Storage Viewer provides a complete view of a contract's on-chain state. Soroban contracts store data in key-value pairs, and this tool decodes both keys and values into readable formats.

Storage Types

Soroban supports three types of contract storage, each with different characteristics:

PERSISTENT

Persistent Storage

Long-term storage that persists indefinitely. Used for critical data like token balances, ownership records, and configuration. Requires rent payments to maintain.

TEMPORARY

Temporary Storage

Short-lived storage that expires after a set number of ledgers. Used for session data, temporary locks, and caching. No rent required but data may be purged.

INSTANCE

Instance Storage

Storage tied to the contract instance itself. Used for contract-level configuration, admin addresses, and version information. Persists with the contract.

Storage Table

The Storage Viewer displays contract state in a sortable, searchable table:

ColumnDescription
KeyDecoded storage key (e.g., Balance:GABC...XYZ)
TypeStorage type badge (Persistent/Temporary/Instance)
ValueDecoded value with type information
TTLTime-to-live (ledgers remaining for temporary storage)
Last ModifiedLedger sequence when value was last changed

Example: Token Contract Storage

// Token contract storage entries (decoded)
┌────────────────────────────────────┬────────────┬─────────────────┐
│ Key                                │ Type       │ Value           │
├────────────────────────────────────┼────────────┼─────────────────┤
│ Admin                              │ Instance   │ GABC...XYZ      │
│ Name                               │ Instance   │ "MyToken"       │
│ Symbol                             │ Instance   │ "MTK"           │
│ Decimals                           │ Instance   │ 7               │
│ Balance:GABC...XYZ                 │ Persistent │ 1000000000000   │
│ Balance:GDEF...UVW                 │ Persistent │ 500000000000    │
│ Allowance:GABC...XYZ:GDEF...UVW    │ Temporary  │ 100000000000    │
└────────────────────────────────────┴────────────┴─────────────────┘

Storage Snapshots

Team and higher tiers can access historical storage snapshots to see how contract state has changed over time. Snapshots are taken at regular intervals and can be compared side-by-side to track state changes.

~>Event Stream

Soroban contracts emit events to communicate state changes and important actions. The Event Stream feature provides both historical event logs and real-time streaming for monitoring contract activity.

Event Structure

Each Soroban event contains the following decoded information:

{
  "type": "contract",           // Event type: contract, system, or diagnostic
  "ledger": 12345678,          // Ledger sequence when event was emitted
  "timestamp": "2026-02-13T10:30:00Z",
  "contract_id": "CDLZ...XYZ",
  "topics": [                  // Event topics (indexed, searchable)
    "transfer",                // Topic 0: Event name
    "GABC...XYZ",              // Topic 1: From address
    "GDEF...UVW"               // Topic 2: To address
  ],
  "data": {                    // Event data payload
    "amount": 1000000000
  }
}

Event Types

CONTRACT

Events explicitly emitted by the contract code. These are the primary events for tracking business logic.

SYSTEM

Events generated by the Soroban runtime. Includes contract deployment, upgrade, and lifecycle events.

DIAGNOSTIC

Debug events for development. Only available in certain network configurations.

Real-Time Streaming

TEAM+Available for Team tier and above

Real-time event streaming uses Server-Sent Events (SSE) to push new events to your browser as they occur on the network. No polling required.

To enable real-time streaming:

  1. Navigate to the Events tab for a contract
  2. Click the "Live Stream" toggle in the top-right
  3. New events will appear automatically as they are emitted
  4. Click any event row to view decoded details

Event Filtering

Filter events by:

  • Event type - Contract, System, or Diagnostic
  • Topic - Filter by specific topic values (e.g., "transfer")
  • Date range - Historical events within a time window
  • Ledger range - Events from specific ledger sequences

Common Event Patterns

EventTopicsUse Case
transfer["transfer", from, to]Token transfers
approve["approve", owner, spender]Allowance approvals
mint["mint", to]Token minting
burn["burn", from]Token burning

AIAI Explanations

Coming Soon

AI Explanations is currently in development and not yet enabled. This feature will be available in a future release. The documentation below describes the planned functionality.

AI Explanations use advanced language models to analyze contract calls and provide plain-English explanations of what happened. This feature is designed to help developers, auditors, and non-technical users understand complex smart contract interactions without deep Soroban expertise.

How It Works

  1. Select a contract call from the Call History
  2. Click the "Explain" button
  3. The AI analyzes the decoded call data, parameters, and context
  4. A plain-English explanation is generated and displayed
  5. Explanations are cached for 7 days to save API credits

Example Explanation

// Contract call: transfer(from, to, amount)

{
  "function": "transfer",
  "from": "GABC...XYZ",
  "to": "GDEF...UVW",
  "amount": 1000000000
}
AI Explanation

Summary: This transaction transfers 100 tokens from account GABC...XYZ to account GDEF...UVW.

Details: The transfer function was called to move tokens between two accounts. The amount of 1,000,000,000 represents 100 tokens (assuming 7 decimal places, which is standard for Stellar assets). The transaction was successful and consumed 234,567 stroops of gas.

Explanation Types

Basic Explanation

A concise summary of what the contract call does. Suitable for quick understanding.

Detailed Analysis

In-depth explanation including parameter breakdown, gas analysis, and potential implications.

Security Review

Highlights potential security considerations, unusual patterns, or risk factors.

Comparison

Compare multiple calls to identify patterns or differences in behavior.

Usage Limits

AI Explanations are subject to monthly limits based on your subscription tier:

TierAI Explanations/Month
FreeNot available
Developer ($25/mo)50
Team ($99/mo)500
AuditorUnlimited
EnterpriseUnlimited

Caching

AI explanations are cached for 7 days. If you request an explanation for a call that was already analyzed, the cached response is returned instantly without counting against your monthly limit.

XDR Decoding

XDR (External Data Representation) is the binary encoding format used by Stellar and Soroban for all on-chain data. Our decoder handles the complex task of parsing XDR and converting it to readable JSON.

Supported XDR Types

TransactionEnvelope
TransactionResult
TransactionMeta
LedgerEntry
ContractEvent
SCVal (Soroban Values)

Decoding Process

// 1. Raw XDR (Base64 encoded)
AAAABQAAAADo...base64...==

// 2. Parse binary XDR structure
{ type: "SCVal", value: { type: "Map", entries: [...] } }

// 3. Convert to readable format
{
  "balances": {
    "GABC...XYZ": 1000000000,
    "GDEF...UVW": 500000000
  }
}

Soroban Data Types

Soroban uses a rich type system for contract data. The explorer decodes all native types:

TypeDescriptionExample
AddressStellar account or contract addressGABC...XYZ
i128128-bit signed integer1000000000
u128128-bit unsigned integer1000000000
SymbolShort string identifier (max 32 chars)"transfer"
StringVariable-length string"MyToken"
BytesRaw byte array0x1a2b3c...
VecDynamic array[1, 2, 3]
MapKey-value mapping{key: value}
BoolBoolean valuetrue / false

API Reference

Programmatic access to contract data is available via REST API for Developer tier and above.

GET/api/contracts/search

Search for contracts by ID, name, or deployer

Query params:qlimitoffset
GET/api/contracts/[contractId]

Get contract details including metadata and statistics

GET/api/contracts/[contractId]/calls

Get decoded call history with pagination

Query params:functioncallerstatusfromto
GET/api/contracts/[contractId]/storage

Get decoded contract storage entries

Query params:type(persistent|temporary|instance)
GET/api/contracts/[contractId]/events

Get decoded contract events

Query params:typetopicfrom_ledgerto_ledger
GET/api/contracts/[contractId]/events/streamSSE

Real-time event stream via Server-Sent Events (Team+ only)

POST/api/contracts/[contractId]/calls/[callId]/explainComing Soon

Get AI-powered explanation for a contract call

GET/api/contracts/[contractId]/export

Export contract data in CSV or JSON format

Query params:format(csv|json)type(calls|storage|events)
GET/api/contracts/[contractId]/analytics

Get contract analytics including gas usage, call frequency, and error rates

Need Help with Soroban?

Our team can help you explore contracts, debug issues, or integrate with the Soroban Pro API.