LogoLogo
  • 📖What is Spire?
  • 🗼Pylon
    • Quickstart
    • Run Based Appchain
    • Architecture Overview
    • Features
      • Become a Pylon Partner
    • FAQs
  • 🌊DA Builder
    • Blob Aggregation Conceptually
  • 📡Preconf Router
    • Developer API
    • Tutorial
  • 🧱Based Stack
    • Spire's flavor of L2 based sequencing
    • Customizable composability
    • Preconfirmations in the Based Stack
    • Execution environment / virtual machine
    • Sequencing revenue (MEV) retention
    • Traditional shared sequencing
    • Open source and credibly neutral
    • Future upgrades
    • What's holding L2 based rollups back today?
    • GitHub [spire-labs/based-stack]
  • 🏫Education Hub
    • Ethereum L2 Based Rollups
    • Based resources
    • Sequencing on Ethereum L1
    • Preconfirmations on Ethereum L1
    • Synchronous Composability
    • What is a based rollup?
Powered by GitBook
LogoLogo

About Spire

  • Website
  • Writings
  • Career
  • Media Kit

Follow Us

  • X
  • Farcaster
On this page
  • Sync Zones
  • Appchain Nodes
  • Port Contracts
  • Priming Transactions
  • Forwarding Proxy Contracts
  • Example Cross-Chain Transaction
Edit on GitHub
  1. Pylon

Architecture Overview

PreviousRun Based AppchainNextFeatures

Last updated 1 day ago

The following details Pylon specific concepts. For details regarding regular chain architecture and components see .

Sync Zones

Spire enables synchronous composability across chains that sit under the same parent chain. This is done through coordinated sequencing. Our current design leverages a single large node that acts as the coordinating sequencer across all appchains in a sync zone.

  • A sync zone dictates which chains can interact as if they were all on the same chain.

  • Which chains are within your sync zone is determined by which other chains are running under the same coordinator (ultimately limited by the settlement chain they operate within).

Appchain Nodes

These are nodes that can be used for following the chain, indexing the chain, etc. but they are read only. Writes must pass through the Coordinator or through the Settlement chain in order to be properly simulated, sequenced, and/or executed.

Port Contracts

Priming Transactions

Cross-chain calls are dynamically detected by Pylon and their results are injected into the Port Contract to pre-populate the required data to fulfill the call. The system transaction used to pre-populate the required data is called a Priming Transaction.

Forwarding Proxy Contracts

Example Cross-Chain Transaction

Port contracts are smart contracts that serve as the interface for cross-chain communication. They receive and store the results of cross-chain calls, allowing transactions to access data from other chains as if they were executing on the same chain. The transactions that populate these contracts are called . This enables synchronous composability between chains within a .

The name "Port Contract" reflects their role as the landing point for data "shipped" across chains. They work in conjunction with , which provide a developer-friendly abstraction layer. This abstraction allows developers to interact with contracts on other chains using the same interface they would use for local contracts, making cross-chain development feel like single-chain development. See for details on how this works.

A forwarding proxy contract is really just a regular proxy contract that you can call into as if it were your target contract on your target chain. It forwards all the necessary data to the to retrieve the results of your cross-chain call.

🗼
Priming Transactions
sync zone
forwarding proxy contracts
here
Port Contract
here