Orphan Pool Data Structure for Blockchain Transaction Deadlock Resolution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Blockchain nodes face a deadlock problem when validating transactions, as they repeatedly try and fail to validate child transactions with unavailable or orphan parent transactions, leading to inefficiencies in transaction processing.
Innovation Solution
A computer-implemented method and data structure, referred to as an 'orphan pool', are used to represent and organize orphan transactions. This involves maintaining a directed graph of nodes and edges, where each node represents an orphan or unavailable transaction, and edges represent the spending of outputs. The orphan pool is updated by adding or removing nodes based on the availability of parent transactions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If blockchain nodes continuously attempt to validate child transactions with unavailable parent transactions, then transaction validation thoroughness is improved, but processing efficiency deteriorates due to repeated failed validation attempts
Solution Approach 1:
The patent extracts orphan transactions from the main validation pipeline and places them in a separate orphan pool. This isolation prevents the validation pipeline from repeatedly attempting to validate transactions that cannot be validated yet, thereby maintaining validation thoroughness for valid transactions while eliminating wasted processing cycles on orphan transactions.
Solution Approach 2:
The patent implements preliminary classification of transactions upon receipt, identifying orphan transactions before they enter the validation pipeline. By marking and separating these transactions in advance, the system prevents future validation attempts until parent transactions become available, thus avoiding repeated failed validations and improving overall processing efficiency.
2Reliability
If blockchain nodes maintain a complete transaction validation queue, then transaction processing completeness is improved, but system complexity increases due to managing orphan transaction dependencies
Solution Approach 1:
The patent segments the transaction management system into two distinct components: the main validation pipeline for valid transactions and the orphan pool for transactions with unavailable parents. This segmentation simplifies the overall system by clearly defining the role and state of each transaction type, reducing the complexity of managing transaction dependencies while ensuring complete processing of all transactions.
3Productivity
If blockchain nodes isolate orphan transactions from the validation pipeline, then transaction validation efficiency is improved, but information flow between transactions is restricted
Solution Approach 1:
The patent implements a feedback mechanism where the orphan pool continuously monitors the validation pipeline for newly validated parent transactions. When a parent transaction becomes available, the system automatically detects this change, retrieves dependent orphan transactions from the pool, and adds them to the validation queue. This feedback loop ensures continuous information flow and maintains transaction processing efficiency without losing inter-transaction information.
Data Source
AI summary
A computer-implemented method performed by a blockchain node and comprising: maintaining a data structure representing orphan transactions, wherein an orphan transaction is a blockchain transaction having at least one parent transaction that is an unavailable transaction and/or at least one parent transaction that is a different orphan transaction, wherein an unavailable transaction is a transaction that is not available to a validation pipeline of blockchain node, and wherein: the data structure comprises a directed graph of nodes and edges, wherein each node of the graph represents either a respective orphan transaction or a respective unavailable transaction, wherein each edge connecting a respective parent node to a respective child node represents the spending of an output of the respective transaction represented by the respective parent node by an input of the respective transaction represented by the respective child node.