On-Demand Query

Gas fees are the fundamental transaction cost on EVM-compatible blockchains, paid in the native token (e.g., ETH). They compensate validators for computation and storage. Key components:

• Base Fee: A mandatory, algorithmically set fee burned by the network.
• Priority Fee (Tip): An optional incentive paid to validators for faster transaction inclusion.
• Gas Limit: The maximum computational units a user is willing to pay for.

Services providing remote procedure call (RPC) access to blockchains use various models:

• Freemium Tier: Limited requests per second (RPS) for free, with paid tiers for higher limits.
• Pay-as-you-go: Charges per request, often with volume discounts (e.g., $0.000001 per request).
• Enterprise/Subscription: Fixed monthly fee for dedicated endpoints, higher rate limits, and guaranteed uptime.

The Graph uses a decentralized marketplace for subgraph queries. Consumers purchase GRT tokens to pay for queries, which are distributed to Indexers (node operators), Curators (subgraph signalers), and Delegators (stakers). Query costs are determined by:

• Subgraph complexity and indexing cost.
• Market dynamics of Indexer pricing.
• Network usage and demand.

The operational expenses for running blockchain data infrastructure include:

• Hardware: High-performance servers, SSDs, and bandwidth for full nodes and indexers.
• Storage: Long-term archival of historical state and event logs.
• Engineering & Maintenance: DevOps for node synchronization, software updates, and monitoring. These costs are typically baked into the pricing of RPC providers and decentralized indexing services.

Maximal Extractable Value (MEV) creates a secondary fee market. Searchers bid via priority fees to have their transactions (e.g., arbitrage, liquidations) included in specific block positions. This drives up gas costs during high-demand periods. Flashbots and other MEV-relay services create private channels for these transactions, impacting the public mempool's economics.

EIP-1559 overhauled Ethereum's fee market by introducing:

• Variable Block Size: Blocks expand and contract based on demand.
• Base Fee Burn: The base fee is destroyed (burned), making ETH deflationary.
• Improved UX: Users set a max fee and priority fee, with automatic refunds for unused gas. This creates more predictable fee estimation but does not inherently lower costs during peak congestion.

The primary security layer for on-demand queries is robust API key management. This includes:

• Authentication & Authorization: Verifying user identity and scoping permissions to specific data sets or query types.
• Rate Limiting: Preventing Denial-of-Service (DoS) attacks and ensuring fair resource allocation by capping requests per key.
• Key Rotation & Revocation: Enforcing policies for regular key updates and immediate revocation if a key is compromised.

Malicious actors may attempt query injection attacks, similar to SQL injection, by crafting inputs that manipulate the query execution logic. Mitigations include:

• Strict Input Validation: Enforcing schema and type constraints on all user-provided parameters.
• Parameterized Queries: Using predefined query templates where user input is treated as data, not executable code.
• Sandboxed Execution: Running queries in isolated environments with limited system access to prevent data exfiltration or system calls.

Blockchain data can contain or be correlated with Personally Identifiable Information (PII). On-demand systems must implement:

• Data Anonymization: Stripping or hashing identifiers (e.g., IP addresses, certain metadata) from query results.
• Differential Privacy: Adding statistical noise to aggregate results to prevent re-identification of individuals from large datasets.
• Compliance Frameworks: Adhering to regulations like GDPR, which may require query auditing and the 'right to be forgotten' for off-chain linked data.

Complex on-demand queries can consume excessive computational resources, leading to high operational costs or system instability. Key controls are:

• Compute Budgeting: Assigning a maximum cost (in gas, CPU time, or memory) per query and terminating execution if exceeded.
• Query Complexity Analysis: Estimating resource requirements before execution and rejecting prohibitively expensive requests.
• Billing & Quotas: Implementing usage-based billing and tiered quotas to align user incentives with system capacity.

Users must trust that query results are accurate and derived from the canonical chain state. This requires:

• State Proofs: Providing cryptographic Merkle proofs or zero-knowledge proofs that verify the returned data is part of a specific, validated block.
• Timestamping & Non-Repudiation: Logging queries and their results with tamper-evident timestamps to provide an audit trail.
• Source Attestation: Clearly identifying the data source (e.g., specific node client, archive node version) to account for potential chain reorganizations.

The underlying infrastructure hosting the query engine must be secured against standard attack vectors:

• DDoS Protection: Mitigating volumetric attacks that target API endpoints.
• TLS/SSL Encryption: Ensuring all data in transit is encrypted to prevent eavesdropping or man-in-the-middle attacks.
• Secure Node Access: If the system queries live nodes, those nodes must be secured against unauthorized access and sybil attacks to prevent data poisoning.

A set of rules and protocols that allows different software applications to communicate. In this context, an on-demand query service exposes a query API (often GraphQL or REST) that applications call to fetch specific data. The API abstracts away the complexity of the underlying indexer or database, providing a clean, documented interface for developers to integrate blockchain data into their dApps.

A full node that retains the complete historical state of a blockchain from the genesis block, unlike a standard full node which may prune old data. Archival nodes are the primary data source for building comprehensive historical indexes. On-demand query services for historical data (e.g., "Show all DEX trades for this wallet in 2021") rely on data sourced and processed from archival nodes.