Local Transform

Instead of moving raw data to a separate analytics engine, Local Transform processes data at the source. This allows for complex calculations—like rolling averages, cumulative sums, or custom aggregations—to be performed within the query itself, returning only the final result.

• Example: Calculating a 30-day moving average of a token's price directly from raw price feed events.
• Benefit: Reduces data transfer and enables real-time analytics on live data streams.

The transform logic is executed locally in the user's environment (e.g., browser, application server, or edge function). This decentralizes computation, shifting the workload from centralized indexers or APIs to the endpoint requesting the data.

• Key Concept: Moves the "heavy lifting" of joining, filtering, and summarizing data to the client.
• Use Case: A dashboard that aggregates a wallet's total DeFi exposure across multiple protocols in a single query.

Local Transform applies a schema or data model at the time of querying, not when the data is written. This provides immense flexibility to reinterpret raw blockchain events (logs, traces) for different analytical purposes without modifying the underlying data pipeline.

• Example: The same raw Transfer event can be transformed to show token flow, calculate net balances, or identify whale movements based on the query's needs.
• Advantage: Enables exploratory data analysis without pre-defining all possible use cases.

By performing transformations locally, the system minimizes round trips to remote servers and avoids querying massive, unprocessed datasets over the network. Only the necessary aggregated result is transmitted or stored.

• Efficiency: Queries run faster as they operate on a refined, in-memory dataset post-initial fetch.
• Cost Saving: Drastically reduces bandwidth and centralized cloud processing costs associated with moving and storing petabytes of raw chain data.

Local Transform differs fundamentally from traditional Extract, Transform, Load (ETL). In ETL, data is transformed in a centralized warehouse before querying. Local Transform defers this step, applying transformations during the query execution.

• ETL: Transform → Store → Query (inflexible, pre-computed).
• Local Transform: Extract → Query + Transform (flexible, on-demand).
• Result: Enables ad-hoc analysis that isn't limited by pre-built tables or cubes.

Effective Local Transform relies on a set of core data primitives and operations provided by the query engine or SDK.

Common primitives include:

• Filters & Slicers: Isolate specific time windows, addresses, or event types.
• Aggregators: Functions for sum, average, count, max/min.
• Window Functions: For time-series operations like rolling_sum or rate_of_change.
• Joins: Merge data from different sources (e.g., prices with transaction history).

These are composed within a query to build the desired transformation pipeline.

Local Transform refers to the execution of data transformation and aggregation logic on the client side, using raw blockchain data (e.g., from an RPC node or indexer). This enables:

• Real-time dashboards that update with each new block.
• Privacy-preserving analytics where sensitive queries never leave the user's machine.
• Reduced infrastructure costs by shifting compute from centralized backends to the edge.

SQL (Structured Query Language) has emerged as the dominant standard for defining local transforms due to its declarative nature and developer familiarity. Engines parse SQL queries to create execution plans that run against local data caches.

• Example: SELECT SUM(value) FROM transactions WHERE block_timestamp > NOW() - INTERVAL '1 day'
• This allows analysts to use well-known tools and patterns for on-chain data analysis.

Local transforms require a reliable feed of raw data. This is typically provided by:

• RPC Nodes: Direct queries for the latest state (e.g., via Ethers.js, Viem).
• Streaming Services: Services like Apache Kafka or Google Pub/Sub delivering real-time block data.
• Indexers: Pre-processed datasets from projects like The Graph or Goldsky, often delivered as cloud storage files (Parquet).

Developer frameworks abstract the complexities of data sync and query execution. They provide:

• Declarative Schemas: Define the blockchain entities (blocks, logs, traces) as queryable tables.
• Incremental Materialization: Efficiently update local state as new blocks arrive.
• Example: A framework might let a developer write a transform that materializes a user_balances table, which is automatically updated and queryable in sub-second time.

Local transform architecture enables several high-performance applications:

• Portfolio Trackers: Real-time, multi-wallet P&L calculations.
• On-Chain Alerting: Custom logic triggers notifications for specific contract events.
• Data Science Workflows: Researchers run complex statistical models on historical chain data locally.
• Decentralized Frontends: DApps that render complex, personalized views without backend APIs.

Local Transform enables light clients and full nodes to process and index blockchain data without relying on centralized indexers. This allows for the creation of custom data views, such as tracking token balances for a specific wallet or aggregating DeFi protocol events, directly from the raw chain state.

• Key Benefit: Eliminates reliance on third-party API services.
• Example: A wallet app using a local transform to calculate a user's total portfolio value across multiple chains.

Projects can build real-time analytics engines by applying transformations to streaming block data. This is critical for block explorers, protocol dashboards, and risk monitoring systems that require sub-second latency and data sovereignty.

• Key Benefit: Enables custom, high-performance metrics calculation (e.g., TVL, trading volume, fee burn).
• Example: A DEX analytics page that computes impermanent loss and pool composition directly from event logs.

By processing data locally, applications can query specific information without exposing user addresses or query patterns to external servers. This aligns with zero-knowledge principles and self-sovereign data models.

• Key Benefit: Users retain control over their data footprint and query history.
• Example: A zk-rollup client that locally verifies state transitions without revealing transaction details to a central indexer.

Local transforms are used to normalize and reconcile state from multiple heterogeneous blockchains into a unified data model. This is foundational for cross-chain bridges, omnichain applications, and aggregated liquidity protocols.

• Key Benefit: Creates a consistent abstraction layer over disparate chain architectures (EVM, SVM, Cosmos).
• Example: A bridge validator node locally transforming proof formats and block headers from different chains to verify asset transfers.

Transform logic can be used to monitor for specific on-chain conditions and trigger downstream actions. This powers automated trading bots, keeper networks, and conditional payment systems.

• Key Benefit: Enables complex, event-driven workflows with deterministic execution.
• Example: A liquidation bot that locally monitors loan health ratios on a lending protocol and submits transactions when thresholds are breached.

Applying transforms at the data ingestion point creates an immutable, verifiable record of how derived data was calculated from its source. This is essential for regulatory reporting, protocol audits, and dispute resolution.

• Key Benefit: Provides cryptographic proof of data integrity and transformation logic.
• Example: A DeFi protocol generating compliance reports by locally transforming raw transaction logs into accounting entries, with each step traceable to a block hash.