💻Computation Node Architecture

Overview

The Computation Node architecture provides a robust and efficient solution for transforming raw data into graph data and executing complex data-driven queries in a decentralized network. This document outlines the architecture's key components and features, covering data processing, rewards distribution, data verification, monitoring, fault tolerance, and security mechanisms.

Key Use Cases:

Data Transformation: The Computation Node converts raw table data into graph data by applying machine learning models to establish relationships. This involves retrieving data from Raw Data Nodes, processing it, and saving the resulting graph data to Graph Data Nodes.

Query Execution: The Computation Node performs advanced graph queries based on user requests in natural language. It uses natural language processing (NLP) to interpret the request, retrieves relevant graph data, executes the query, and returns the results.

Core Features:

On-Chain Proof of Stake (PoS) Incentives: Nodes earn rewards based on the resources consumed during computation (CPU, RAM, time). These rewards are calculated and distributed via smart contracts on the blockchain, ensuring transparency and traceability.

Licensing System with NFTs: When a user purchases a license to operate a Computation Node, they receive a non-fungible token (NFT) representing that license. The system validates the node’s operation on the blockchain using this NFT, ensuring that each license corresponds to only one active node. This mechanism prevents multiple nodes from using the same license.

Data Verification: Ensures that accurate and verified graph data is utilized in computations.

Monitoring Capabilities: Maintains internal graphs for network conditions, data distribution, and system state.

Fault Tolerance and Efficient Computation: Guarantees task completion even if nodes fail and minimizes redundant computations across the network.

Geolocation Awareness: Uses node geolocation to optimize task assignment and resource usage.

Security and Data Integrity: Employs cryptographic hash validation for computation verification and ensures that state or data hashes are stored on the blockchain.

1. Graph Data Storage Approach

1.1. Neo4j Integration

Data Storage in Neo4j: Computation Nodes interact with Neo4j instances running on Graph Data Nodes to store and retrieve graph data. The data structure supports unweighted, directed graphs, suitable for representing complex relationships.

Metadata Management: Alongside the graph data, metadata (e.g., ownership, access permissions, data history) is maintained to support access control and lifecycle policies.

1.2. Adaptive Data Replication

Dynamic Replication Factor: Graph data is stored across multiple nodes with a dynamically calculated replication factor, adjusted based on the network size and node availability. This ensures fault tolerance while optimizing storage efficiency.

Data Rebalancing: As nodes join or leave the network, graph data is redistributed to maintain consistent replication levels. The system uses sharding to ensure balanced distribution.

2. Graph Distribution and Retrieval

2.1. Distributed Index and Retrieval

Distributed Index Mapping: The system maintains a distributed index that maps graph IDs to nodes storing the data. This index is decentralized and updates dynamically when data is relocated or replicated.

Data Retrieval Workflow: When a user requests a graph, the Computation Node performs a lookup in the distributed index to find the relevant data location. It retrieves the data from the Graph Data Node and caches the results to improve future access times.

2.2. Caching Mechanism

Caching for Performance: Frequently accessed graph data is temporarily cached by Computation Nodes to reduce latency and load on primary storage nodes. Cache expiration policies ensure data consistency by removing outdated cached entries.

Cache Invalidation Protocol: When a graph is updated, notifications are sent to nodes with cached copies, prompting them to invalidate the outdated data.

3. Proof of Stake and Rewards Calculation

3.1. On-Chain Rewards Distribution

Resource-Based Incentives: Nodes earn rewards proportional to the computational resources they contribute (CPU cycles, memory usage, computation time). These rewards are calculated on-chain to ensure transparency.

Reporting to PoS Smart Contract: Nodes periodically submit resource usage metrics to a PoS smart contract, which calculates and distributes rewards based on these metrics.

Dynamic Reward Scaling: Rewards are adjusted based on task complexity, encouraging nodes to handle more demanding computations.

3.2. Penalty Mechanisms

Non-Compliance Penalties: Nodes that fail to meet task requirements (e.g., incomplete computations, incorrect results) may lose rewards or face token forfeitures.

Incentives for High Performance: Nodes that perform exceptionally well in completing tasks or contributing to verification receive bonus rewards.

4. Data Verification and Integrity

4.1. Verification Process

Graph Data Validation: Computation Nodes only use data verified through hash checks or signatures. This ensures that all computations are based on reliable graph data.

Result Hashing: After computation, nodes generate a cryptographic hash (e.g., SHA-256) of the results. The hash serves as proof of computation and is stored on the blockchain for transparency and integrity.

Consensus-Based Verification: When multiple nodes perform the same computation, they compare hashes to validate the results. If a majority agree, the result is accepted; otherwise, additional validation is triggered.

4.2 Licensing with NFTs

NFT Licensing System: When a user purchases a license to operate a Graph Data Node, they receive a non-fungible token (NFT) that represents that license. The system validates the node’s operation on the blockchain using this NFT, ensuring that each license corresponds to only one active node.

On-Chain License Validation: The smart contract ensures that only one node can operate under a given license at any time. This mechanism enhances security and accountability within the network.

5. Avoiding Duplicated Computation Using Hash Validation

To prevent redundant computations while ensuring data integrity, a subset of nodes is designated for computation and hash validation. This approach guarantees accurate results without duplicating tasks across the entire network.

5.1. Task Assignment Strategy

Primary and Secondary Nodes: When a computation task is requested, a primary Computation Node is selected to perform the initial computation, while a few secondary nodes (e.g., three to five) are assigned to validate the results independently.

Node Selection Criteria: The selection of secondary nodes is randomized to prevent bias and potential collusion. Factors such as node availability, past performance, and geographic proximity to the data source are considered.

5.2. Hash Validation and Consensus

Computation and Hash Generation: Both the primary and secondary nodes execute the task and generate a hash of the computed result. This hash serves as a fingerprint of the computation's outcome.

Majority Agreement: If a majority of nodes (e.g., at least 3 out of 5) generate the same hash, the computation is considered valid. This consensus mechanism ensures that the result is accurate and has not been tampered with.

Handling Discrepancies: If the hashes do not match across the validating nodes, the system may trigger a re-execution by a new set of nodes or conduct deeper investigation to resolve inconsistencies.

5.3. Reward Distribution Based on Contribution

Primary Node Rewards: The primary node receives the main reward for completing the computation first and submitting the initial hash.

Secondary Node Rewards: The validating nodes earn smaller rewards for verifying the primary node’s result. This encourages nodes to participate in validation without duplicating the entire computational workload.

Incentives for Identifying Errors: If a validating node identifies an error in the primary computation, it receives a bonus reward for flagging the discrepancy. This promotes thorough verification.

Penalties for Incorrect Computations: Nodes submitting incorrect results may face penalties, such as forfeiture of rewards or staked tokens, discouraging malicious behavior.

5.4. Task Coordination to Prevent Overlapping Computations

Task Assignment Coordination: The network maintains a record of active tasks and their assigned nodes to ensure that each computation is performed by the designated nodes only. This prevents multiple nodes from redundantly executing the same task.

Randomized Selection for Fairness: Node selection for validation is randomized, making it difficult for any group of nodes to monopolize validation tasks.

5.5. Fault Tolerance During Computation

Checkpointing Mechanism: Long-running tasks save intermediate results at regular intervals (checkpoints). If a node fails, another node can resume from the latest checkpoint, minimizing redundant work.

Dynamic Task Reallocation: If a primary or secondary node fails during computation, the task is automatically reassigned to another node. This ensures that the computation continues without significant delays.

6. Geolocation Awareness

6.1. Geolocation Determination

IP-Based Geolocation Services: Nodes can use IP-based geolocation to estimate their physical location. This information is utilized to optimize task assignment and reduce network latency.

User-Provided Location Data: In cases where IP-based location is insufficient, node operators can manually provide geolocation information to enhance accuracy.

6.2. Utilizing Geolocation for Optimization

Proximity-Based Task Distribution: Computation tasks are assigned to nodes that are geographically closer to the data source to minimize latency and improve performance.

Regional Load Balancing: Geolocation data helps distribute computational tasks across different regions, avoiding regional bottlenecks and ensuring efficient resource utilization.

7. Monitoring and Internal Graphs

7.1. Internal Graphs for System Monitoring

Graph of Network Conditions: Tracks node connectivity, network latency, and data transfer rates. This graph is updated in real-time to reflect current network conditions.

Graph of Data Distribution: Visualizes the location and replication status of datasets, ensuring data is stored redundantly and evenly distributed across the network.

Graph of System State: Monitors resource usage metrics such as CPU load, memory usage, and I/O rates, enabling predictive maintenance and system optimization.

7.2. Predictive Analytics for Maintenance

Anomaly Detection: The system employs predictive models to detect unusual behavior patterns, such as sudden spikes in resource usage or unexpected data growth, triggering alerts for potential issues.

Proactive Scaling: By analyzing trends, the system can proactively scale resources or redistribute tasks to avoid performance degradation.

8. Security and Verification of Computations

8.1. Ensuring Data Integrity and Correctness

Computation Result Hashing: The hash generated after computation serves as a digital fingerprint, stored on the blockchain for verification. This ensures that any tampering with the result is easily detectable.

Result Auditing by Other Nodes: Nodes periodically re-compute tasks and compare the hashes with the stored hashes to ensure consistency. Any discrepancies trigger further investigation or additional verification steps.

8.2. Access Control and Task Permissions

Task-Specific Access Policies: Nodes enforce strict access controls based on the nature of the computation and the requesting user's permissions.

Role-Based Task Assignment: Tasks are assigned to nodes with appropriate permissions and resource capabilities to ensure secure and efficient processing.

9. Smart Contract Design

9.1. Integration with PoS Smart Contract

Resource Usage Reporting: Nodes periodically submit detailed metrics (CPU usage, memory consumption, computation duration) to the PoS smart contract, which calculates rewards.

Automated Reward Distribution: The smart contract automatically distributes rewards to nodes based on the reported metrics and the consensus reached during hash validation.