Mercury Documentation
  • Get Started with Mercury
    • Pricing
    • Endpoints
    • Authentication
  • The Definitive Guide to Understanding The Mercury's Stack Vision
  • Retroshades
    • Introduction to Retroshades
    • Get Started
      • Importing the Retroshades SDK
      • Writing and Emitting Retroshades
      • Deploying to Mercury Retroshades
      • Querying Retroshades
  • Zephyr: Full Customization
    • Introduction
    • General concepts
      • Zephyr Programs
      • Accessing the Ledger: Contract Entries
      • Accessing the Ledger Meta: Contract Events
      • Database Interactions
      • Create Custom Callable APIs: Serverless Functions
      • Catchups
      • Using Soroban inside Zephyr
    • Quickstart
    • Learn
      • Introduction to Mercury's Cloud and the Zephyr Stack
      • Get Started: Set Up and Manage the Project
        • Create the Project
        • Writing the Program
        • Local Testing
        • Deploy
        • Data catchups/backfill
        • Monitor Execution
        • Querying
      • Database Interactions
        • Zephyr.toml: Define the Tables Structure
        • Understanding Database Interactions
        • Database Operations
      • Accessing the Ledger
      • Accessing Ledger Transition: Soroban Events
      • Working with Contract Custom Types
      • Working with Soroban SDK Types
      • Web Requests, Automation and Alerts.
      • Zephyr.toml Extensions: Indexes And Dashboard
      • Reading From Indexes/External Tables
      • Custom APIs - Serverless Functions
        • General Concepts
        • Custom RPC-alike Endpoints
        • Querying APIs for Composable Data
      • Data Catchups/Backfill
      • Custom Dashboards
        • Creating the Dashboard
        • Plotting: Simple
        • Complex Plotting
    • Support
  • Mercury "Classic"
    • Subscriptions
      • API Definition
    • Queries
      • Contract Events
      • Contract Data Entry Updates
      • Stellar Operations, Balances, and Account Objects
  • TUTORIALS
    • Zephyr
      • Self-hosting Zephyr
      • No-RPC Dapp
      • Indexing a DeFi liquidity pool (Blend)
      • Building a Secure DeFi Real-Time Bot Through Smart Accounts
      • Monitoring Large Deposits with Zephyr and Sending Web Alerts
    • Mercury Classic
      • Index and query contract events
Powered by GitBook
On this page
  • Charming
  • Accessing Data From Other Available Tables
  1. Zephyr: Full Customization
  2. Learn

Custom Dashboards

Learn how to create custom dashboards with Zephyr

PreviousData Catchups/BackfillNextCreating the Dashboard

Last updated 10 months ago

Until now you learned that Mercury's cloud environment can:

  • execute custom code that specifies data workflows and processing.

  • catchup on all events.

But the party doesn't end here. One of the perks of relying on a WASM machine that isn't scared of memory allocation (we're off-chain, which means that things are much easier to manage and distribute) is the possibility of using the large selection of crates that the Rust ecosystem offers.

Charming

One of these awesome crates is , which with a is compatible with Zephyr's execution. Charming allows you to build dashboards with charts that can be plotted without requiring further instructions using Apache ECharts.

That's why we are launching a community charts dashboard very soon in our roadmap, where developers can create and publish charts about their protocols, aggregations of various protocols, etc.

Currently, you can create such charts, but you'll either have to host the front-end that plots them or ask the Mercury team to have your chart featured in the dashboard.

The existing curated dashboards are:

    • allocation across all pools.

    • time series of the supply, collateral, and amount borrowed for each pool and asset.

    • Learn more in the upcoming blog post!

Accessing Data From Other Available Tables

As already mentioned, Zephyr works in a way such that public tables that are being live-updated as soon as the ledger closes can be queried from other Zephyr programs.

This is incredibly powerful especially for dashboards, in that you will be able to create dashboards relying on data that's already indexed by other programs which might for example have been written by/in collaboration with the creators of the protocols themselves!

Learn more about this at .

charming
very slight change
curated charts
Blend Mainnet dashboard