Block Explorer

// Examples
key:owner           → Find all SCs with "owner" variable
value:TELA-INDEX    → Find all TELA INDEX contracts
code:STORE("votes"  → Find voting contracts
author:dero1qy...   → Find all apps by this address

// API
AddSearchExclusion(filter string) -> { success: true }
RemoveSearchExclusion(filter string) -> { success: true }
GetSearchExclusions() -> { filters: ["scid1...", "scid2..."] }
ClearSearchExclusions() -> { success: true }

SetSearchMinLikes(percent int) -> { success: true }

{
    // Core identifiers
    height, topoheight, hash,
    
    // Block metadata
    depth, difficulty, nonce,
    major_version, minor_version,
    
    // Status flags
    orphan_status, sync_block, side_block,
    
    // DAG structure
    tips: []string,  // Parent block hashes
    
    // Mining info
    miners: []string,
    miner_address: string,  // Extracted from coinbase TX
    reward: uint64,
    
    // Timing
    timestamp, age, block_time,
    
    // Transactions
    tx_count, tx_hashes: []string,
    txs: []TxSummary,  // Type, fee per TX
    total_fees: uint64,
    
    // Size
    size_bytes, size_kb,
    
    // Raw data
    blob: string,
}

{
    txid, tx_type,
    
    // Status
    in_pool, ignored, is_coinbase,
    
    // Block info
    block_height, valid_block,
    invalid_blocks: []string,
    
    // Timing
    age, block_time,
    
    // Build info
    height_built, blid, root_hash,
    
    // Addresses
    miner_address, signer,
    
    // Economics
    fee, reward, burn_value, balance,
    
    // Ring members PER PAYLOAD (critical for privacy)
    rings: []PayloadRing{
        index: int,
        members: []string,  // Full addresses
        count: int,
    },
    ring_count, max_ring_size,
    
    // Assets breakdown PER PAYLOAD
    assets: []Asset{
        index: int,
        scid: string,
        fees: uint64,
        burn: uint64,
        ring_size: int,
        ring: []string,
    },
    
    // Smart Contract data
    sc_args, sc_code, sc_balance, sc_balance_now, sc_code_now,
    
    // Size
    size_bytes, size_kb,
    
    // Raw data
    hex: string,
    output_indices,
}

const (
    PREMINE      // Genesis allocation
    REGISTRATION // Address registration
    COINBASE     // Mining reward
    NORMAL       // Standard transfer
    BURN_TX      // Token burn
    SC_TX        // Smart contract interaction
)

// Block proofs with impossible amounts
ValidatePayloadProofAmount(amount uint64) error
 
// Get detailed validation with warnings
ValidatePayloadProofAmountWithContext(amount uint64) -> {
    valid: bool,
    error: string,
    warnings: []string,
    supplyContext: string  // "12.5% of current DERO supply"
}
 
// Flag suspicious but valid amounts
DetectSuspiciousProofPatterns(amount uint64) -> []string

const (
    MAX_INT64_SAFE               = 9223372036854775807  // 2^63 - 1
    MAX_REASONABLE_AMOUNT_ATOMIC = 22_000_000_000_000   // 22M DERO
    DERO_HARD_CAP_ATOMIC         = 21_000_000_000_000   // 21M DERO
)

GetSCInfo(scid) -> {
    code: string,      // DVM bytecode
    balance: uint64,   // SC balance
    variables: map,    // All stored variables
}
 
DaemonGetSC(scid) // Direct daemon call

// Invoke SC function (requires wallet approval)
InvokeSCFromExplorer(scid, entrypoint, args, deposit) -> txid
 
// Specific actions
RateTELAApp(scid, rating)           // 0-99 rating
LikeTELAApp(scid)
DislikeTELAApp(scid)

EstimateSCGas(scid, entrypoint, args) -> {
    gascompute: uint64,
    gasstorage: uint64,
    total: uint64,
    cost_dero: string,
}

+----------------------------------------------------------+
|  [Zap] Call Smart Contract Function                       |
+----------------------------------------------------------+
|  Function: [Deposit(amount: Uint64) v]                    |
+----------------------------------------------------------+
|  PARAMETERS                                               |
|  +------------------------------------------------------+ |
|  | amount [Uint64]                                      | |
|  | [_________________________] (number input)           | |
|  +------------------------------------------------------+ |
+----------------------------------------------------------+
|  [DEROVALUE] DERO Amount to Send                          |
|  [_____________] DERO                                     |
+----------------------------------------------------------+
|  [ ] Anonymous transaction (ringsize 16)                  |
|  ! SIGNER() detected - anonymous mode disabled            |
+----------------------------------------------------------+
|  [         Call Deposit         ]                         |
+----------------------------------------------------------+

ParseSCFunctions(scid) -> {
    success: bool,
    functions: []SCFunction{
        name: string,           // "Deposit"
        params: []SCParam{
            name: string,       // "amount"
            type: string,       // "Uint64" or "String"
            dataType: string,   // "U" or "S" for XSWD
        },
        returnType: string,     // "Uint64"
        usesDero: bool,         // DEROVALUE() detected
        usesAsset: bool,        // ASSETVALUE() detected
        usesSigner: bool,       // SIGNER() detected
    },
    count: int,
}

InvokeSCFunction(paramsJSON) -> {
    success: bool,
    txid: string,
    function: string,
    message: string,
}
 
// paramsJSON structure:
{
    scid: "abc123...",
    function: "Deposit",
    params: { "amount": 1000 },
    deroAmount: 100000,        // Atomic units (0.001 DERO)
    assetScid: "",             // Token SCID if sending asset
    assetAmount: 0,
    anonymous: false,          // Use ringsize 16
}

InstallSmartContract(code, anonymous) -> {
    success: bool,
    txid: string,
    message: string,
}

// Capture current state
CaptureSCState(scid) -> SCStateSnapshot
 
// Retrieve historical state
GetSCStateAtHeight(scid, height) -> SCStateSnapshot

// Compare two heights
CompareSCStateAtHeights(scid, from, to) -> SCStateDiff
 
// Get change timeline
GetSCChangeTimeline(scid) -> []SCStateDiff

┌──────────────────────────────────────────────────────────────┐
│ ◎ SMART CONTRACT                                             │
│                         0.00500 DERO │ View as TX │  Watch   │
└──────────────────────────────────────────────────────────────┘

// Watch SC for changes
WatchSmartContract(scid, name) -> {
    success: true,
    message: "Now watching abc123..."
}
 
// Unwatch SC
UnwatchSmartContract(scid) -> {
    success: true
}
 
// Get all watched SCs
GetWatchedSmartContracts() -> {
    success: true,
    watched: [
        {
            scid: "abc123...",
            name: "My App",
            watched_since: "2026-01-03T10:00:00Z",
            last_checked: "2026-01-03T12:00:00Z",
            last_change: "2026-01-03T11:30:00Z",
            change_count: 3
        },
        ...
    ],
    count: 2
}
 
// Manually refresh all watched SCs
RefreshWatchedSCs() -> {
    success: true,
    changes_detected: 1  // Number of SCs that changed
}

type SCStateDiff struct {
    SCID          string
    FromHeight    uint64
    ToHeight      uint64
    BalanceDiff   int64
    Changes       []SCStateChange
    TotalAdded    int
    TotalModified int
    TotalRemoved  int
    CodeChanged   bool
}

+----------------------------------------------------------+
|  [History] HISTORICAL TIMELINE                            |
+----------------------------------------------------------+
|  [o--------o--------o--------o--------o] Height Slider    |
|   1000     2500     4000     5500     Current             |
+----------------------------------------------------------+
|  Viewing state at height: 4000                            |
|  +------------------------------------------------------+ |
|  | owner     | dero1qy...abc                            | |
|  | balance   | 50000                                    | |
|  | status    | "active"                                 | |
|  +------------------------------------------------------+ |
+----------------------------------------------------------+

// Get all recorded snapshots for an SC
GetSCIDTimeline(scid) -> {
    success: bool,
    timeline: []SnapshotInfo{
        height: int64,
        timestamp: int64,
        varCount: int,
    },
    count: int,
}
 
// Get SC state at a specific height
GetSCIDStateAtHeight(scid, height) -> {
    success: bool,
    height: int64,
    variables: {
        stringkeys: map[string]string,
        uint64keys: map[string]uint64,
    },
}
 
// Compare state between two heights
CompareSCIDHeights(scid, height1, height2) -> {
    success: bool,
    height1: int64,
    height2: int64,
    added: []VariableChange,
    modified: []VariableChange,
    removed: []VariableChange,
}

// Get storage statistics
GetHistoryStats() -> {
    success: bool,
    totalSCIDs: int,
    totalSnapshots: int,
    maxSnapshots: int,
}
 
// Configure snapshot limits
SetMaxSnapshots(max) -> { success: bool }
 
// Clear history for specific SC
ClearSCIDHistory(scid) -> { success: bool }
 
// Clear all historical data
ClearAllHistory() -> { success: bool }

GetMempoolTransactions()  // Basic pending transaction list
GetMempoolExtended(max)   // Detailed mempool with full TX info
GetNetworkInfo()          // Chain height, difficulty, peers
GetBlockchainStats()      // Comprehensive stats

{
    txs: []MempoolTx{
        hash, type, fee, fee_dero,
        size_bytes, size_kb,
        ring_size, ring_count,
        signer, in_pool,
    },
    count: int,           // Returned count
    total_count: int,     // Actual mempool size
    truncated: bool,      // If > maxCount
    
    // Aggregate stats
    total_fees, total_fees_dero,
    total_size_bytes, total_size_kb,
    
    // Type breakdown
    type_stats: {
        NORMAL: int,
        SC: int,
        BURN: int,
        OTHER: int,
    },
}

SearchAddress(address) -> {
    ownedSCIDs: []  // SCIDs where address is owner
}
GetAddressSCIDReferences(address) // SCIDs where address appears

// Forward lookup (name -> address)
ResolveDeroName(name) -> address
 
// Reverse lookup (address -> name)
GetNameForAddress(address) -> name
 
// Cache management
GetNRSCacheStats()
GetAllCachedNames()