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
  • Setting up the project
  • Write, Deploy, and Monitor your Program
  1. Zephyr: Full Customization
  2. General concepts

Zephyr Programs

We have already covered what a Zephyr program is, now let's try to get a clearer picture of it.

Setting up the project

Each Mercury account can initialize and deploy a Zephyr program by following the steps on the Quickstart or the "Set up and manage project" section. With a simple Zephyr SDK command, you can create a Rust project that includes a Zephyr.toml file, where you can define the structure of the database tables that your program will access.

Write, Deploy, and Monitor your Program

Once you're all set, you can start writing your logic in the program. When you're finished the program will be deployed and:

  • Run for every new ledger close while performing the specified logic.

  • Be called through a web request to execute the predefined logic, if you're using it as a custom API.

  • Do both.

It's possible to control the program's execution from Mercury's app, where you can start, pause, and see its logs. Now, let's explore what it means to create your own logic in the program and the various types of actions that can be executed.

PreviousGeneral conceptsNextAccessing the Ledger: Contract Entries

Last updated 7 months ago