A distributed ledger storage method, apparatus, device, and medium for multi-center clinical trials.
By using local logical clock vectors and root hash digests in multi-center clinical trials, the throughput bottleneck and ledger fork problem during concurrent writes across multiple nodes were solved, improving the system's stability and throughput.
Patent Information
- Application Number
- CN202611232560.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-14
- Publication Date
- 2026-11-10
AI Technical Summary
In multi-center clinical trial scenarios, existing distributed ledger storage solutions suffer from insufficient throughput and frequent ledger forks when multiple nodes are writing concurrently, and asynchronous alignment lag leads to reduced system stability.
By binding data entities with local logical clock vectors and generating root hash feature digests, alignment scheduling is initiated through a data collaborative consensus engine, and differential reconstruction is performed using non-blocking data streams to achieve strong consistency convergence of the global ledger state.
It improves the overall throughput and convergence stability of distributed ledger storage in multi-center clinical trial scenarios, avoids queuing and blocking of global serial consensus, and efficiently eliminates state deviations between nodes.
Smart Images

Figure CN123067787A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of distributed storage technology, and more specifically, to a distributed ledger storage method, apparatus, device, and medium for multi-center clinical trials. Background Technology
[0002] In the complex business scenario of multi-center clinical trials, which involve cross-regional and multi-institutional collaboration, building a collaborative data storage network, employing multiple nodes to maintain local state copies, and relying on consensus to maintain the global sequence is a common technical approach in this field. To ensure that discretely distributed storage entities maintain time-series traceability in an environment without a central node, each physical node typically mounts the incoming data records to its own dedicated discrete storage shards according to a fixed time sequence, thereby establishing distributed data replica blocks.
[0003] In the field of distributed ledgers, several improvement schemes have been proposed to address the bottleneck of global serial consensus. For example, ledger structures based on directed acyclic graphs (DAGs) (such as IOTA and Hashgraph) improve throughput through parallel writing; sharded parallel consensus (such as Ethereum 2.0) divides the network into multiple shards to process transactions in parallel. However, the above schemes still have limitations in the specific scenario of multi-center clinical trials: DAG-type ledgers lack a global serialization control mechanism for highly competitive core transactions, which can easily lead to business logic conflicts when rewriting competitive resources across centers; sharded parallel consensus has high cross-shard transaction coordination overhead, making it difficult to meet the requirements of strong consistency and time-series traceability in clinical trial data management.
[0004] Conventional distributed ledger storage methods, in order to maintain the authenticity, integrity and tamper-proofness of data in decentralized network topologies, are limited by the throughput bottleneck caused by the serial consensus across the entire network. They force all physical nodes in the network to share an absolutely consistent global logical timestamp axis.
[0005] This means that any discrete data packets written concurrently must undergo full linear sorting within the network. When geographically dispersed nodes receive high-concurrency data write requests within the same physical time window, the limitations of data consistency control become apparent. Specifically, in the absence of a global time synchronization node, each storage entity can only rely on its local physical clock to mark the timing of data frames. The unordered state updates from discrete access cannot accurately determine causal dependencies. When overlapping writes are performed on data in a highly contentious state, the feature summaries generated by each node's local shards are prone to deviation, leading to frequent data forks in the ledger storage path during the global data coordination and alignment process.
[0006] To mitigate these conflicts, conventional improvement approaches tend to broaden communication bandwidth or embed static serial locks at the global access layer. However, broadening bandwidth only increases transmission rate and cannot adaptively avoid timing conflicts; while static serial locks require multiple nodes to queue during concurrent writes, significantly limiting the throughput efficiency of distributed storage systems and potentially causing fragmented storage timeouts and crashes. A deeper limitation lies in the imbalance between storage increment speed and channel mass transfer capacity. When a node receives massive amounts of data and mounts it in place, the local fragmented ledger evolves rapidly, while the network channel's transmission capacity remains in a steady and limited state. This results in severe execution lag and logical fallback in background asynchronous alignment, which can still lead to distributed state machine transition deadlocks or high-frequency ledger forks under non-ideal conditions. The transaction data written by each node is multidimensional, heterogeneous, and varies in size. Concurrent writes can easily lead to a surge in fragmentation of the ledger storage block space. When instantaneous jitter or partitioning occurs in cross-regional networks, the network-wide consensus clock becomes disordered, triggering frequent permanent ledger forks. The system must consume enormous computing resources to complete rollbacks and fork arbitrations, resulting in a significant reduction in the real-time performance and stability of data management in distributed storage networks. Existing improvement methods mainly achieve this through external business cache optimization, upgrading physical network hardware, or changing the chain topology. However, they still cannot fundamentally solve the inherent timing conflict problem of the underlying timing consensus mechanism of distributed storage during concurrent writes.
[0007] In other words, in the existing technology, there are technical problems in multi-center clinical trial scenarios where the existing solutions lack an effective balance mechanism between local temporal decoupling and strong competitive transaction consistency. This leads to insufficient storage throughput and easy ledger forking when multiple nodes are writing concurrently, as well as reduced system stability due to asynchronous alignment lag. Summary of the Invention
[0008] Some embodiments of this disclosure propose a distributed ledger storage method, apparatus, device, and medium for multi-center clinical trials, in order to improve the technical problems in the prior art, such as throughput bottlenecks and frequent ledger forks caused by global time-series serial consensus during concurrent writing of multiple nodes, as well as the reduced system stability caused by asynchronous alignment lag.
[0009] To achieve the above objectives, this application adopts the following technical solution: A distributed ledger storage method for multicenter clinical trials includes: The front-end data access gateway receives write requests initiated by multi-center clinical trial nodes and transforms the write requests into abstract data entities; The front-end data access gateway collects the local logical clock vector inside the current physical node, binds the local logical clock vector to the abstract data entity, controls the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generates a root hash feature digest. The data collaboration consensus engine in the distributed storage network initiates alignment scheduling to each physical node based on preset alignment triggering conditions, instructing each physical node to exchange the root hash feature digest and complete the literal consistency comparison of the root hash feature digest; When the result of the literal consistency comparison indicates that the root hash feature digest between the two physical nodes has deviated, the data state differential reconstruction procedure is triggered, and the physical node that initiated the alignment is controlled to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream. The peer storage node receives the non-blocking data stream and uses the received sharded chain segments to perform incremental merging of the local global distributed ledger, achieving strong consistency convergence of the global ledger state.
[0010] In a preferred embodiment of this application, in the above-described distributed ledger storage method for multi-center clinical trials, before the step of the front-end data access gateway converting the write request into an abstract data entity, the method further includes: The front-end data access gateway has a built-in transaction attribute recognition action that divides the received write requests into non-contact independent transactions and highly contested core transactions. When a transaction is determined to be an independent transaction without competition, the write request unconditionally enters the local decoupling path. When a transaction is determined to be a highly competitive core transaction, the local decoupling path is suspended, the write request is redirected to the network-wide distributed queuing synchronization lock path, and the ledger write can only be completed after more than two-thirds of the physical nodes in the distributed storage network have reached a consensus.
[0011] In a preferred embodiment of this application, in the aforementioned distributed ledger storage method for multicenter clinical trials, when it is determined that the current write request involves rewriting competitive material inventory across centers, the local storage manager within the physical node embeds a physical transaction causal dependency vector composed of the states of each central node into the descriptive label of the abstract data entity.
[0012] In a preferred embodiment of this application, in the above-mentioned distributed ledger storage method for multi-center clinical trials, along with the mounting action of the abstract data entity, the local storage manager inside the physical node reads the physical attributes of the latest mounted block in the current discrete ledger storage shard, points the block header hash pointer of the newly written block to the tail hash value of the previous block, and connects them to form a complete chain of causal evolution relationship. The local storage manager simultaneously calculates the overall storage state within the current discrete ledger storage shard and generates the root hash feature digest based on the multi-node shard state matrix maintained by this node.
[0013] In a preferred embodiment of this application, in the aforementioned distributed ledger storage method for multi-center clinical trials, the data collaboration consensus engine is further used to determine whether there is a business state logic conflict caused by multiple nodes concurrently modifying the same highly competitive core transaction. When a business state logic conflict is determined to exist, the data collaboration consensus engine extracts the conflicting abstract data entities into an independent logically isolated running rack, reads the physical transaction causal dependency vector, completes the nonlinear directed acyclic graph topological sorting according to the physical causal order of the physical transaction causal dependency vector, generates compensation adjustment instructions in situ to offset state deviations, and directly appends the compensation adjustment instructions as new blocks to the end of the global distributed ledger.
[0014] In a preferred embodiment of this application, in the above-described distributed ledger storage method for multi-center clinical trials, each physical node periodically captures a static topological image of the global distributed ledger consensus convergence point and stores it locally. When the data collaboration consensus engine determines that the current physical node fails to achieve asynchronous alignment due to data fork or data replay attack, the physical node activates the antifragile self-healing program, freezes the current active ledger, and rolls back the overall running state to the latest legal static topology mirror point that is locally solidified and saved. After the rollback is completed, the physical node uses the static topology mirror point as the new source reference and sends a directional traceback request to the other legitimate physical nodes in the distributed storage network. It then pulls the legitimate incremental abstract data entity stream after the mirror point in one direction, completes the discrete replay calculation locally, and reconstructs the sharded ledger in situ.
[0015] In a preferred embodiment of this application, in the above-mentioned distributed ledger storage method for multi-center clinical trials, a data density monitor is deployed inside the physical node. The data density monitor counts the cumulative number of unaligned abstract data entities in the current discrete ledger storage shard at a frequency of seconds, and establishes the ratio of the cumulative number of bytes to the duration of a preset physical time window as a local storage incremental density index. When the local storage incremental density index exceeds the preset network bandwidth security threshold, the communication gateway reads the real-time idle connection status of the peer consensus node, switches the node-aligned communication link to an adaptive multi-channel parallel cascading mode, and positively adjusts the length of the data transmission frame according to the extent of the network bandwidth security threshold exceedance, compressing the proportion of edge redundancy check bits in the data transmission frame to release physical network bandwidth.
[0016] This application also provides a distributed ledger storage device for multicenter clinical trials, comprising: The data access and conversion module is used to receive write requests initiated by multi-center clinical trial nodes through the front-end data access gateway and convert the write requests into abstract data entities. The local clock binding and mounting module is used to collect the local logical clock vector inside the current physical node through the front-end data access gateway, bind the local logical clock vector to the abstract data entity, control the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generate the root hash feature digest; The digest comparison module is used to initiate alignment scheduling to each of the physical nodes based on preset alignment triggering conditions through the data collaborative consensus engine in the distributed storage network, instructing each of the physical nodes to exchange the root hash feature digest, and to complete the literal consistency comparison of the root hash feature digest; The differential reconstruction module is used to trigger the data state differential reconstruction program when the result of the literal consistency comparison indicates that the root hash feature digest between the two physical nodes has deviated, and to control the physical node that initiated the alignment to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream. The incremental merging module is used to receive the non-blocking data stream through the peer storage node, and use the received sharded chain segments to perform incremental merging on the local global distributed ledger, thereby achieving strong consistency convergence of the global ledger state.
[0017] Based on the above, this application also provides an electronic device, including: a memory for storing a computer program; and a processor connected to the memory for executing the computer program stored in the memory to implement the above-described distributed ledger storage method for multi-center clinical trials.
[0018] Based on the above, this application also provides a computer-readable storage medium storing a computer program that, when executed, performs the various steps of the distributed ledger storage method for multi-center clinical trials described above.
[0019] The above-described embodiments of this disclosure have the following beneficial effects: The distributed ledger storage method for multi-center clinical trials provided in this application firstly transforms write requests into abstract data entities through a front-end data access gateway; secondly, it collects local logical clock vectors as qualifier tags and binds them, controlling physical nodes to mount the abstract data entities to local discrete ledger storage shards according to a monotonically increasing law, and generates root hash feature digests; then, the data collaborative consensus engine initiates alignment scheduling, instructing each physical node to exchange root hash feature digests and complete literal consistency comparisons; subsequently, when a deviation in the root hash feature digest is detected, a data state differential reconstruction procedure is triggered, pushing the corresponding discrete ledger storage shards to the peer storage node in the form of a non-blocking data stream; finally, the peer storage node uses the received shard chain segments to perform incremental merging of its local global distributed ledger. Based on the above, due to the adoption of local logical clock vector decoupling of global timing and asynchronous differential alignment based on root hash digests, the distributed storage network can avoid queuing and blocking of global serial consensus during high-concurrency writes, and can efficiently eliminate state deviations between nodes by pushing shard chain segments in a targeted manner. This can significantly improve the overall throughput and convergence stability of distributed ledger storage in multi-center clinical trial scenarios, thereby improving the throughput bottleneck and frequent ledger forks caused by global time-series serial consensus during multi-node concurrent writes in existing technologies. Attached Figure Description
[0020] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and elements are not necessarily drawn to scale.
[0021] Figure 1 A structural block diagram of an electronic device provided in an embodiment of this application.
[0022] Figure 2 This is a flowchart illustrating a distributed ledger storage method for multi-center clinical trials provided in an embodiment of this application.
[0023] Figure 3 This is a schematic diagram illustrating the principle of dual-track transaction processing and conflict arbitration in the distributed ledger storage method for multi-center clinical trials provided in this application embodiment.
[0024] Figure 4 This is a block diagram of a distributed ledger storage device for multicenter clinical trials provided in an embodiment of this application. Detailed Implementation
[0025] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.
[0026] It should also be noted that, for ease of description, only the parts relevant to the invention are shown in the accompanying drawings. Unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.
[0027] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.
[0028] It should be noted that the terms "a" and "a plurality of" used in this disclosure are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".
[0029] The names of messages or information exchanged between multiple devices in the embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.
[0030] To facilitate understanding of the technical solutions of this application, the following definitions are given for specific terms appearing in this application: (1) Abstract data entity: refers to the standardized internal data object generated by the front-end data access gateway after it performs unified structuring processing on the received raw write request data of different formats. This data object contains at least a data payload area, metadata header and time series tag field, which is used to shield the heterogeneity of the underlying data sources of different clinical trial centers.
[0031] (2) Local logical clock vector: refers to the logical counter maintained independently by each physical node to represent the order of write events within the node. This vector does not need to be absolutely synchronized with the clocks of other physical nodes in the network. It only needs to ensure that the timestamp corresponding to each write event is strictly monotonically increasing within the node.
[0032] (3) Root hash feature digest: refers to the fixed-length hash value that can uniquely represent the current overall state of the local discrete ledger storage shard, which is obtained by the physical node after calculating all data blocks in the local discrete ledger storage shard based on the hash tree (such as Merkle tree) algorithm. If the data content of any two node shards is completely identical, their root hash feature digests will necessarily be the same; conversely, if there are any differences in the data content, the root hash feature digests will be completely different.
[0033] (4) Non-blocking data stream: refers to a data push and transmission mode. In this mode, after the data sender sends the data, it can continue to perform subsequent processing tasks without waiting for the receiver's confirmation response, thereby avoiding performance blockage of the sender due to network transmission delay or slow processing speed of the receiver.
[0034] (5) Antifragile self-healing procedure: refers to a set of systematic state recovery procedures that are automatically activated by a physical node when asynchronous alignment fails due to data fork, network partition, or external attack. This procedure includes at least: freezing the currently active ledger, rolling back the overall running state to the latest legal static topology mirror point that is permanently stored locally, pulling incremental data after the mirror point from other legal nodes in the network, and completing discrete replay calculation and ledger reconstruction locally.
[0035] (6) Strongly Competitive Core Transactions and Non-Competitive Independent Transactions: These are categorized based on whether the write request involves concurrent modification of shared resources across nodes. Strongly competitive core transactions refer to requests involving rewriting globally unique resources (such as inventory of clinical trial research products with specific serial numbers, or subject enrollment eligibility). Non-competitive independent transactions refer to requests involving data generated independently by this node and not competing for resources with other nodes (such as original file quality control records, or subject daily check-in data). Distinguishing these transactions aims to employ different processing paths to optimize the overall system throughput efficiency.
[0036] This disclosure will now be described in detail with reference to the accompanying drawings and embodiments.
[0037] like Figure 1 As shown in the illustration, this application provides an electronic device. The electronic device may include a memory, a processor, and a distributed ledger storage device for multi-center clinical trials.
[0038] Optionally, the memory may be, but is not limited to, random access memory (RAM), read-only memory (ROM), programmable read-only memory, erasable read-only memory, electrically erasable read-only memory, etc.
[0039] Optionally, the processor may include at least one of a central processing unit (CPU), a digital signal processor, an application-specific integrated circuit, a field-programmable gate array, or other programmable logic devices.
[0040] Understandable. Figure 1 The structure shown is for illustrative purposes only; the electronic device may also include components that are more advanced than those shown. Figure 1 The more or fewer components shown, or having the same Figure 1 The different configurations shown.
[0041] Combination Figure 2 and Figure 3 This application also provides a distributed ledger storage method for multi-center clinical trials that can be applied to the aforementioned electronic devices. The following will describe... Figure 2 The specific process shown will be explained in detail.
[0042] S1: The front-end data access gateway receives write requests initiated by multi-center clinical trial nodes and transforms the write requests into abstract data entities.
[0043] In this embodiment, the front-end data access gateway is a logical functional unit deployed at the forefront of the physical nodes of each clinical trial center, responsible for handling the initial access and standardization processing of all external write requests. Multi-center clinical trial nodes refer to independent physical servers or server clusters distributed across different regions, medical institutions, or research centers. The data write requests initiated by these nodes carry various transaction data from the clinical trial process.
[0044] For example, the data may include, but is not limited to, original document quality control records, project initiation compliance documents, daily participant attendance data, inventory change data of clinical research products, and participant eligibility establishment data. This data is an indispensable component of clinical trial data management, and its authenticity, completeness, and chronological traceability are crucial to the compliance of clinical trial results.
[0045] Transforming write requests into abstract data entities refers to converting the diverse data payloads from the original requests, which vary in format and protocol, into a standardized internal data format that can be uniformly processed by subsequent storage modules. This transformation process may include sub-steps such as data format normalization, extraction of key fields, and filtering of irrelevant information. Through this transformation, the heterogeneity of the underlying data source can be effectively shielded, laying the foundation for subsequent unified storage processing.
[0046] In an alternative implementation, if the data format of the write request already conforms to the preset standardization specifications, the conversion action can be simplified to format confirmation and entity encapsulation, without the need to perform complete data cleaning and reconstruction.
[0047] S2: The front-end data access gateway collects the local logical clock vector inside the current physical node, binds the local logical clock vector to the abstract data entity, controls the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generates a root hash feature digest.
[0048] In this embodiment, the local logical clock vector is the core mechanism for achieving local decoupling of global timing. Unlike traditional schemes that rely on a global physical clock or a global logical clock, this application maintains an independent, monotonically increasing logical clock counter within each physical node. This counter is not required to be absolutely synchronized with the clocks of other nodes; it only needs to ensure that within its own node, the timestamp corresponding to each write event is strictly monotonically increasing.
[0049] Specifically, after completing the transformation of the abstract data entity, the front-end data access gateway immediately reads the current value of the local logical clock inside the current physical node. This value constitutes the local logical clock vector. In this application, this vector can be understood as a simple integer value or a set of monotonic numerical sequences.
[0050] Binding the local logical clock vector directly to the abstract data entity as a qualifier label means that the clock value is treated as an indivisible attribute field of the data entity, stored and processed along with the data entity. In this way, each data entity is assigned a unique and incremental time identifier within its own node upon generation.
[0051] Subsequently, based on the monotonically increasing pattern of the local logical clock vector, the physical node writes the abstract data entity into its local, dedicated discrete ledger storage shard. In-situ mounting refers to the data entity being directly written to a designated storage area of the physical node's local memory (such as a solid-state drive or disk array) without immediately broadcasting it to other nodes across the network. The core advantage of this approach is that it decomposes the timing determination actions, which originally required sequential ordering across the entire network, into independent, parallel timing determination actions within each node, thereby fundamentally eliminating the queuing bottleneck caused by global serial consensus.
[0052] It should be noted that a local, dedicated discrete ledger storage shard is a contiguous storage space independently maintained on each physical node, used to store data blocks received and processed by that node. Within each shard, data blocks are linked through hash pointers, forming an independent local causal chain.
[0053] Along with the mounting action of the abstract data entity, the local storage manager inside the physical node reads the physical attributes of the latest mounted block in the current discrete ledger storage shard, points the block header hash pointer of the newly written block to the tail hash value of the preceding block, and connects them to form a complete chain of causal evolution. The local storage manager simultaneously calculates the overall storage state within the current discrete ledger storage shard and generates the root hash feature digest based on the multi-node shard state matrix maintained by this node. The root hash feature digest is a fixed-length hash value calculated by each physical node for all data content of its local discrete ledger storage shard using a hash tree (such as a Merkle tree) algorithm, uniquely representing the current overall state of that shard.
[0054] The multi-node sharding state matrix is a data structure maintained by this node that represents the discrete ledger storage sharding state of each physical node in the distributed storage network at the latest consensus convergence point. The matrix is N×M dimensional, where N is the total number of physical nodes and M is the feature dimension of each node's sharding state (including but not limited to: root hash feature digest value, latest block height, local logical clock vector, and number of unaligned data bytes). The element in the i-th row and j-th column of the matrix represents the state value of the i-th physical node in the j-th feature dimension.
[0055] In one specific embodiment of this application, before the aforementioned S2, a step of transaction attribute identification and dual-track traffic splitting may be included. Specifically, the front-end data access gateway has a built-in transaction attribute identification action, which divides the received write requests into non-contested independent transactions and highly contested core transactions. The non-contested independent transactions may include original file quality control records, project initiation compliance documents, and daily attendance data of subjects, etc. These transactions usually do not involve resource contention between multiple nodes, so their processing paths can remain local and parallel. The highly contested core transactions may include inventory change data of clinical research products and enrollment eligibility data of subjects, etc. These transactions often involve modifications to globally unique resources and require stricter consistency control.
[0056] When a transaction is determined to be an independent transaction without competition, the write request unconditionally enters the local decoupling path, i.e., the in-situ mounting action in S2 above is executed. When a transaction is determined to be a core transaction with strong competition, the local decoupling path is suspended, and the write request is redirected to the network-wide distributed queuing synchronization lock path. The ledger write can only be completed after consensus is reached by more than two-thirds of the physical nodes in the distributed storage network. This dual-track processing mechanism enables the system to maximize overall throughput efficiency while ensuring strong consistency requirements.
[0057] It should be noted that the network-wide distributed queuing synchronization lock path set up in this application does not negate the principle of "global temporal decoupling." The local decoupling path primarily serves uncontested independent transactions, which constitute the vast majority of clinical trial data write requests. These write operations do not involve cross-node resource contention, thus allowing for safe independent temporal determination and mounting on the local node. However, for highly contested core transactions, the objects of modification are globally unique resources (e.g., a specific number of experimental drug inventory, subject enrollment eligibility). Concurrent rewriting of this resource by different nodes must be strictly serialized; otherwise, business logic errors that cannot be compensated for through post-processing will occur. In other words, the above dual-path design is a divide-and-conquer strategy of "maximizing parallelism for uncontested transactions and necessary serialization for contested transactions," rather than simply reintroducing a serial lock globally. The threshold of consensus among two-thirds of the network nodes only applies to this small subset of traffic—highly contested core transactions. Most write requests still follow the local decoupling path; therefore, the overall system throughput remains significantly higher than a forced global serialization scheme.
[0058] In this embodiment of the application, the physical transaction causal dependency vector is a fixed-length composite data structure, and its fields are defined as follows: (1) origin field: records the physical node ID that initiated the strong competition core transaction, occupying 4 bytes; (2) clock_snapshot field: Records a snapshot of the local logical clock vector of the initiating node at the time of this transaction, that is, the vector clock currently maintained by the node. A complete copy, occupying bytes, where N is the total number of physical nodes in the distributed storage network; (3) The resource_version field records the current global version number of the target competing resource (such as a specific numbered clinical trial research product inventory record) involved in the transaction, which occupies 8 bytes; the version number is determined by the height of the latest block corresponding to the resource in the global distributed ledger; (4) timestamp field: records the physical timestamp (UTC) of the transaction, which occupies 8 bytes and serves as an auxiliary sorting reference.
[0059] The physical transaction causal dependency vector is embedded in the modifier tag of the abstract data entity. Specifically, an additional field named causal_dep is extended into the modifier tag. This field is serialized in TLV (Type-Length-Value) format and directly appended to the local logical clock vector field. Together with the remaining fields of the modifier tag, it constitutes the complete metadata header of the abstract data entity.
[0060] When the data collaboration consensus engine or the arbitration unit needs to parse the physical transaction causal dependency vector, it completes the reading according to the following path: (1) Extract the Type identifier of the causal_dep field from the modifier label and confirm that the field is a physical transaction causal dependency vector; (2) Determine the data length based on the Length field, and read the origin, clock_snapshot, resource_version and timestamp fields in sequence; (3) Determine the transaction source node based on the origin field, and compare the logical clock vector in the clock_snapshot field with the causal dependency vector of other transactions to be arbitrated to determine the causal order of each transaction.
[0061] In an alternative implementation, to ensure the convergence stability of the asynchronous global alignment process under concurrent write surges, a data density monitor can be deployed inside the physical node. The data density monitor counts the cumulative number of bytes of unaligned abstract data entities in the current discrete ledger storage shard at a rate of seconds, and establishes the ratio of the cumulative number of bytes to a preset physical time window as the local storage incremental density index. The unaligned abstract data entities refer to those data entities that have been locally mounted but have not yet been confirmed and merged into the global consistency state by the global data collaboration consensus engine. When the local storage incremental density index exceeds a preset network bandwidth safety threshold, the communication gateway reads the real-time idle connection status of the peer consensus node, switches the node alignment communication link to an adaptive multi-channel parallel concatenation mode, and positively adjusts the length of the data transmission frame according to the extent of the network bandwidth safety threshold exceedance, compressing the proportion of edge redundancy check bits within the data transmission frame to release physical network bandwidth. Through the combined action of the above multi-channel parallel concatenation and dynamic frame structure adjustment, the system can maximize the transmission rate of effective data and alleviate data flow lag under sudden surges, even with limited physical network bandwidth resources.
[0062] In this embodiment, the local logical clock vector is implemented using a vector clock data structure. Assuming there are N physical nodes in the distributed storage network, a fixed vector dimension index is assigned to each physical node. The local logical clock vector maintained locally by any physical node j. Given an integer vector of length N: in, This represents the currently known logical clock value of physical node k for physical node j. The local logical clock vector follows the following update rules: (1) When a write event occurs locally on physical node j, the node increments the clock value corresponding to its own dimension by 1, i.e. ; (2) When physical node j receives a data stream or state synchronization information from physical node i, the node will... With the peer carried in the data stream Merge by taking the maximum value for each dimension, that is, for all ,make ,in The opposite vector The k-th component; after merging, physical node j increments the clock value corresponding to its own dimension by 1 to record the received event; (3) The local logical clock vector is bound as a qualifier label to the abstract data entity corresponding to each write request, and is transmitted and stored in the distributed storage network along with the data entity.
[0063] Based on the above data structure, each of the two physical nodes a and b maintains its own local logical clock vector. and The following rules can be used to determine causal relationships between individuals: (1) If for all dimensions All have And at least one dimension exists. Make Then determine Cause and effect precede That is, physical node a occurs before physical node b in time; (2) If for all dimensions k, we have If the two logical clock vectors are equal, they correspond to the same global consensus convergence point. (3) Otherwise, that is, there is a dimension. and Make and If the two vectors are in a concurrent relationship (i.e., no causal relationship), then it is determined that the two events occur independently on different physical nodes.
[0064] S3: The data collaboration consensus engine in the distributed storage network initiates alignment scheduling to each physical node based on the preset alignment triggering conditions, instructing each physical node to exchange the root hash feature digest and complete the literal consistency comparison of the root hash feature digest.
[0065] In this embodiment, after possible bandwidth compensation, the network link has better transmission conditions. At this time, the data collaborative consensus engine in the distributed storage network begins to execute global alignment scheduling. The data collaborative consensus engine is a logically centralized control unit responsible for coordinating the state synchronization of all physical nodes in the network.
[0066] One of the core actions of alignment scheduling is to trigger the exchange of root hash feature digests between physical nodes. As long as the shard data content of two nodes is completely identical, the root hash feature digests they calculate will definitely be the same; conversely, as long as there is any slight difference in the data content, the root hash feature digests will be completely different.
[0067] The data collaborative consensus engine performs literal consistency comparison, which means that the engine itself receives and compares the root hash feature digests from different physical nodes. Literal consistency comparison directly compares whether two hash value strings are completely identical. This comparison method has extremely low computational cost, making it very suitable for high-frequency execution in the network, and can quickly detect state differences between nodes at a very low cost.
[0068] S4: When the result of the literal consistency comparison indicates that the root hash feature digest between the two physical nodes has deviated, the data state differential reconstruction procedure is triggered, and the physical node that initiated the alignment is controlled to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream.
[0069] In this embodiment, when the data consensus engine detects an inconsistency in the root hash feature digest between two nodes, it determines that the ledger states of these two nodes have deviated. This deviation may be caused by normal asynchronous merging time differences, or it may be caused by data forks or abnormal writes.
[0070] To efficiently eliminate this deviation, the data collaborative consensus engine triggers a data state differential reconstruction procedure. The core logic of this procedure is that instead of performing full data synchronization, the node with the newest state or more complete data (i.e., the physical node that initiated the alignment) pushes the incremental data since the last alignment point from its corresponding discrete ledger storage shard in the form of a non-blocking data stream to the peer storage node with the lagging state.
[0071] The non-blocking data stream refers to a data transmission operation that does not occupy the processing resources of the sending or receiving end for an extended period. The sending end can continue executing other tasks immediately after sending the data without waiting for confirmation from the receiving end. This transmission method avoids performance degradation of the sending end due to network latency or slow processing at the receiving end. Directed push means that the data stream is sent directly from the sending node to the receiving node without needing to be forwarded or arbitrated by other intermediate nodes, thereby minimizing latency and overhead in the transmission path.
[0072] S5: The peer storage node receives the non-blocking data stream and uses the received sharded chain segments to perform incremental merging of the local global distributed ledger, achieving strong consistency convergence of the global ledger state.
[0073] In this embodiment, after receiving a non-blocking data stream, the peer storage node applies the received sharded segments to its local global distributed ledger. This process is similar to applying a database transaction log, replaying or merging received incremental data blocks to ensure that the state of the local ledger is consistent with that of the node that initiated the alignment.
[0074] A distributed state machine completes a state transition when the receiving node moves the state of its storage system from an "unaligned" state to an "aligned" state. This transition is deterministic, meaning that as long as the received data stream is complete and valid, the result of the state transition is unique and predictable.
[0075] After incremental merging is completed, the two physical nodes involved in the alignment achieve literal consistency at the hash chain level of the ledger data, meaning they are completely identical in data content. By performing the above alignment and merging operations on all nodes across the entire network, all physical nodes in the distributed storage network can eventually converge to the same global ledger state, thus achieving strong consistency.
[0076] The following describes several key aspects of the method of this application in conjunction with specific embodiments.
[0077] The performance data in the following embodiments of this application are based on the following test environment: the distributed storage network consists of 12 physical nodes of clinical trial centers, each node is configured with equivalent processor, memory and local storage resources; the nodes are interconnected via 10Gbps Ethernet, and the average network round-trip latency is approximately 2ms; the data payload size of a single write request is 4KB-64KB, conforming to the clinical trial data resource representation of the HL7 FHIR R4 standard; the local logical clock vector is implemented using a vector clock data structure with dimension N=12. The above performance data are representative results measured in this test environment. In actual deployment, performance data will fluctuate due to differences in hardware configuration, network conditions and data characteristics.
[0078] Explanation regarding dual-track transaction processing and conflict arbitration: Firstly, regarding S1 and S2, in one specific implementation, this embodiment is constructed within a distributed storage network topology consisting of physical nodes from 12 clinical trial center hospitals. Each physical node is discretely deployed in different regions, handling the access and storage of all transactions related to subject screening, raw document quality control, clinical research product transfer, and multi-center data management.
[0079] The front-end data access gateway's built-in transaction attribute identification action classifies received write requests according to the resource contention attributes of the transactions. Specifically, original document quality control records, project initiation compliance documents, and subject daily check-in data are classified as non-competitive independent transactions, while inventory change data of clinical research products and subject enrollment eligibility establishment data are classified as highly competitive core transactions.
[0080] In specific application scenarios, for example, 12 clinical trial center nodes concurrently initiate write requests for daily subject check-in and original document quality control records. Since these data are classified as non-competitive independent transactions, the front-end data access gateway intercepts the write requests and transforms them into abstract data entities. Instead of invoking a network-wide broadcast queuing lock, the system collects the local logical clock vector of each node. Assuming that a center node reads its local clock vector value as [1024, 980, 1011, ..., 995] (corresponding to vector clock snapshots of the 12 centers), the local storage manager mounts this abstract data entity to the 4th discrete ledger storage shard corresponding to the center node. After mounting, the hash pointer of the block header is written to the tail hash string of the preceding block. The entire mounting process is completed locally in situ, taking approximately 1.2ms in actual measurements. The local storage manager then calculates the root hash value of the hash tree within the 4th shard, generating a root hash feature digest. Under normal, non-contact conditions, the global ledger state convergence latency of the distributed storage network remains between 38ms and 45ms. The overall storage throughput of the system under continuous high concurrency reaches 8200 writes per second, and the physical storage space fragmentation rate of all nodes in the network is only 0.02.
[0081] Secondly, regarding the handling of core transactions involving strong competition, in one specific implementation, when it is determined that the current write request involves cross-center competitive material inventory rewriting, the local storage manager inside the physical node embeds a physical transaction causal dependency vector composed of the states of each central node into the descriptive label of the abstract data entity. This vector records the known state information of other nodes currently known to the node initiating the transaction, and is key metadata for achieving distributed causal ordering.
[0082] For example, among 12 central nodes, central node three and central node five simultaneously initiate inventory deduction write requests for the same batch of limited-edition clinical trial research products numbered Drug A, with a concurrency scale set at a high-frequency impact of 2500 times per second. The transaction attribute identification action of the front-end data access gateway determines that the write request belongs to a highly competitive core transaction and involves cross-center competitive material inventory rewriting. The local storage manager embeds the physical transaction causal dependency vector in the descriptive label of this abstract data entity.
[0083] When the data collaboration consensus engine determines that there is a business state logic conflict caused by multiple nodes concurrently modifying the same highly competitive core transaction, it extracts the conflicting abstract data entities into an independent logically isolated running rack, reads the physical transaction causal dependency vector, completes the nonlinear directed acyclic graph topological sorting according to the physical causal order of the physical transaction causal dependency vector, generates compensation adjustment instructions in situ to offset state deviations, and directly appends the compensation adjustment instructions as new blocks to the end of the global distributed ledger.
[0084] Continuing the competition scenario between the three-node and five-node central nodes, the data collaboration consensus engine detected a deviation in the root hash feature digest during the asynchronous global alignment step, attributing the deviation to inventory rewrite conflicts. Instead of blocking the main chain, the system extracts the abstract data entities of the conflicts into an independent, logically isolated runtime environment. The data collaboration consensus engine reads the causal dependency vector of the physical transactions, identifying that the causal vector stamp of the three-node central node is earlier than that of the five-node central node. Based on this, the system completes a non-linear directed acyclic graph topological sort, determining that the inventory deduction of the three-node central node has priority. The system generates an inventory deviation compensation adjustment instruction in situ, which marks the deduction status of the five-node central node as invalid and triggers the material allocation compensation rule. Subsequently, this compensation adjustment instruction is directly appended to the end of the global distributed ledger as a new block. The entire alignment and conflict arbitration process is completed within 72ms. The distributed state machine successfully completes the migration, the ledger hash chains of the two nodes are not disrupted, the global ledger achieves strong consistency convergence, and no permanent forks or inventory overselling occur. In contrast, under the same impact conditions, conventional asynchronous sharded ledger schemes, lacking the intermediate causal transformation medium of physical transaction causal dependency vectors, cannot determine the merging order. As a result, the two active ledgers deadlock and hang after asynchronous merging, and data synchronization is suspended for up to 12 seconds.
[0085] In this embodiment of the application, the nonlinear directed acyclic graph (DAG) is constructed as follows: Let the set of highly competitive core transactions with conflict be denoted as . Each of these transactions Each carries a corresponding physical transaction causal dependency vector. The vertices of a DAG are the conflicting transactions. For any two transactions... and ( Based on the clock_snapshot field in their respective physical transaction causal dependency vectors, the clock causality determination rules are calculated. and The causal relationship between them: (1) If Cause and effect precede Then a directed edge is constructed. , indicating a transaction Must precede transactions implement; (2) If Cause and effect precede Then a directed edge is constructed. , indicating a transaction Must precede transactions implement; (3) If and If the relationship is concurrent, no direct edges are constructed in the DAG, indicating that the two transactions are concurrent operations generated independently by different physical nodes, which can be uniformly handled by subsequent compensation logic.
[0086] After the DAG is constructed, it is topologically sorted. If the sorting result is unique, the transaction is executed directly according to the sorting result; if the sorting result is not unique, the resource_version field (lower version number takes precedence) and the timestamp field (earlier timestamp takes precedence) are used as secondary and tertiary sorting factors to determine the final execution order.
[0087] The compensation adjustment instruction adopts the following data structure: Compensation adjustment instruction {instruction_type:uint8, / / 0x01 = Status invalid, 0x02 = Resource rollback, 0x03 = Allocation compensation target_tx_id:bytes32, / / Hash of the target transaction to be offset target_resource:string, / / Target resource identifier (e.g., inventory number) adjustment_value:int64, / / Adjustment amount (positive for increase, negative for decrease) reason:string, / / Explanation of the compensation reason execute_by:node_id, / / ID of the node executing the compensation prev_compensation: bytes32 / / Hash of the previous compensation instruction, used for chaining} The compensation adjustment instruction is added as a new block. Its block body contains a serialized byte stream of the above data structure, and the block header hash pointer points to the end block of the global distributed ledger, thus appending it to the end of the ledger.
[0088] Explanation of data density-driven bandwidth adaptive compensation and anomaly self-healing: Thirdly, to ensure the convergence stability of the asynchronous global alignment process when facing concurrent write surges, this application provides a data density-driven bandwidth adaptive compensation mechanism. In a specific implementation, a data density monitor deployed inside the physical node counts the cumulative number of bytes of unaligned abstract data entities in the current discrete ledger storage shard at a rate of seconds. The ratio of this cumulative number of bytes to a preset physical time window duration is established as a local storage incremental density index. When this index shows an upward trend within the physical time window and exceeds a preset network bandwidth safety threshold, a dynamic feedforward compensation mechanism of the communication gateway is triggered. In this embodiment, the safety threshold can be set to 50 megabytes per second. Based on the extent of the exceedance, the communication gateway adaptively switches the alignment communication link to a multi-channel parallel cascade mode, adjusts the transmission frame length, and removes edge redundancy check bits. Actual measurements show that the actual physical bandwidth utilization of the network alignment link can be improved by 32%.
[0089] Fourthly, each physical node periodically captures a static topology image of the global distributed ledger consensus convergence point and stores it locally. This operation does not participate in high-frequency local mounting actions but runs as an independent time series, thereby ensuring the reliability and isolation of the image data.
[0090] When the data collaboration consensus engine determines that the current physical node has failed to achieve asynchronous alignment due to data fork or data replay attack, the physical node activates an antifragile self-healing procedure, freezes the currently active ledger, and rolls back the entire running state to the latest valid static topology mirror point that is locally stored. After the rollback is completed, the physical node uses the static topology mirror point as the new source benchmark and sends a directed tracing request to the other valid physical nodes in the distributed storage network. It unidirectionally pulls the valid incremental abstract data entity stream after the mirror point, performs discrete replay calculation locally, and reconstructs the sharded ledger in situ.
[0091] For example, during the normal operation of a multi-center distributed storage network, the external physical network of the eight central nodes is artificially disconnected, leaving them in a network isolated state for 30 minutes. During this period, the front-end data access gateway of the eight central nodes continuously receives discrete quality control files entered by local quality control personnel, and its local discrete ledger storage shards evolve independently for 1800 logical clock cycles. Subsequently, a simulated momentary power outage occurs on the eight central node server, accompanied by an external data replay attack. After the physical server restarts, the eight central nodes activate their antifragile self-healing program. The eight central nodes immediately forcibly freeze the active ledgers of the nodes, and the overall operating state is rolled back to the latest valid static topology mirror point that was locally fixed before the power outage. After the rollback is completed, the eight central nodes send a directed traceback request to the other healthy central nodes in the network, unidirectionally pulling the valid incremental abstract data entity streams from the ledger of the first central node after that mirror point, and the local storage manager completes the discrete replay calculation. During the replay process, the data density monitor detected a surge in the amount of misaligned data, with the local storage incremental density exceeding the set network bandwidth safety threshold. This triggered the communication gateway's dynamic bandwidth compensation action, adaptively switching the communication link with the central node to a 4-channel parallel cascade mode. The transmission frame length was adjusted based on the extent of the out-of-bounds error, and redundant check bits at the edges were removed, resulting in a 32% increase in the actual physical bandwidth utilization of the network alignment link. The eight central nodes completed 1800 cycles of data replay and differential reconstruction in 850ms, restoring the sharded ledger and the global distributed ledger to literal consistency alignment, and the distributed state machine returned to its normal consensus state.
[0092] Combination Figure 4 This application also provides a distributed ledger storage device for multi-center clinical trials that can be applied to the aforementioned electronic devices. The distributed ledger storage device for multi-center clinical trials may include a data access and conversion module, a local clock binding and mounting module, a summary comparison module, a differential reconstruction module, and an incremental merging module.
[0093] The data access conversion module is used to receive write requests initiated by multi-center clinical trial nodes through a front-end data access gateway, and convert the write requests into abstract data entities. In this embodiment, the data access conversion module can be used to perform... Figure 2 For details regarding the data access conversion module shown in step S1, please refer to the previous description of step S1.
[0094] The local clock binding and mounting module is used to collect the local logical clock vector inside the current physical node through the front-end data access gateway, bind the local logical clock vector to the abstract data entity, control the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generate a root hash feature digest. In this embodiment, the local clock binding and mounting module can be used to execute... Figure 2 For details regarding the local clock binding module shown in step S2, please refer to the previous description of step S2.
[0095] The digest comparison module is used to initiate alignment scheduling to each of the physical nodes based on preset alignment trigger conditions through the data collaborative consensus engine in the distributed storage network, instructing each of the physical nodes to exchange the root hash feature digest, and completing the literal consistency comparison of the root hash feature digest. In this embodiment, the digest comparison module can be used to perform... Figure 2 For details regarding step S3 shown, please refer to the previous description of step S3 for information about the summary comparison module.
[0096] The differential reconstruction module is used to trigger a data state differential reconstruction procedure when the result of the literal consistency comparison indicates a deviation in the root hash feature digest between the two physical nodes. This procedure controls the physical node initiating the alignment to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream. In this embodiment, the differential reconstruction module can be used to execute... Figure 2 For details regarding the differential reconstruction module in step S4, please refer to the previous description of step S4.
[0097] The incremental merging module is used to receive the non-blocking data stream from the peer storage node, and use the received sharded segments to perform incremental merging on the local global distributed ledger, achieving strong consistency convergence of the global ledger state. In this embodiment, the incremental merging module can be used to execute... Figure 2 For details regarding step S5 shown, please refer to the previous description of step S5 for information about the incremental merging module.
[0098] In this embodiment of the application, corresponding to the above-described distributed ledger storage method for multi-center clinical trials applied to the electronic device, a computer-readable storage medium is also provided. The computer-readable storage medium stores a computer program, which, when executed, performs various steps of the distributed ledger storage method for multi-center clinical trials. The specific steps executed by the aforementioned computer program are not detailed here, but can be found in the preceding explanation of the distributed ledger storage method for multi-center clinical trials.
[0099] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can also be implemented in other ways. The apparatus and method embodiments described above are merely illustrative. For example, the flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions marked in the blocks may occur in a different order than those marked in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram and / or flowchart, and combinations of blocks in block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.
[0100] In addition, the functional modules in the various embodiments of this application can be integrated together to form an independent part, or each module can exist independently, or two or more modules can be integrated to form an independent part.
[0101] If the aforementioned functions are implemented as software functional modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks. It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.
[0102] The above description is merely a preferred embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.
Claims
1. A distributed ledger storage method for multi-center clinical trials, characterized in that, include: The front-end data access gateway receives write requests initiated by multi-center clinical trial nodes and transforms the write requests into abstract data entities; The front-end data access gateway collects the local logical clock vector inside the current physical node, binds the local logical clock vector to the abstract data entity, controls the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generates a root hash feature digest. The data collaboration consensus engine in the distributed storage network initiates alignment scheduling to each physical node based on preset alignment triggering conditions, instructing each physical node to exchange the root hash feature digest and complete the literal consistency comparison of the root hash feature digest; When the result of the literal consistency comparison indicates that the root hash feature digest between the two physical nodes has deviated, the data state differential reconstruction procedure is triggered, and the physical node that initiated the alignment is controlled to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream. The peer storage node receives the non-blocking data stream and uses the received sharded chain segments to perform incremental merging of the local global distributed ledger, achieving strong consistency convergence of the global ledger state.
2. The distributed ledger storage method for multi-center clinical trials according to claim 1, characterized in that, Before the step of the front-end data access gateway converting the write request into an abstract data entity, the method further includes: The front-end data access gateway has a built-in transaction attribute recognition action that divides the received write requests into non-contending independent transactions and strongly contested core transactions. When a transaction is determined to be an independent transaction without competition, the write request unconditionally enters the local decoupling path. When a transaction is determined to be a highly competitive core transaction, the local decoupling path is suspended, the write request is redirected to the network-wide distributed queuing synchronization lock path, and the ledger write can only be completed after more than two-thirds of the physical nodes in the distributed storage network have reached a consensus.
3. The distributed ledger storage method for multi-center clinical trials according to claim 2, characterized in that, When it is determined that the current write request involves rewriting competitive material inventory across centers, the local storage manager inside the physical node embeds a physical transaction causal dependency vector composed of the states of each center node in the descriptive label of the abstract data entity.
4. The distributed ledger storage method for multi-center clinical trials according to claim 1, characterized in that, As the abstract data entity is mounted, the local storage manager inside the physical node reads the physical attributes of the latest mounted block in the current discrete ledger storage shard, points the block header hash pointer of the newly written block to the tail hash value of the previous block, and connects them to form a complete chain of causal evolution relationship. The local storage manager simultaneously calculates the overall storage state within the current discrete ledger storage shard and generates the root hash feature digest based on the multi-node shard state matrix maintained by this node.
5. The distributed ledger storage method for multi-center clinical trials according to claim 3, characterized in that, The data collaboration consensus engine is also used to determine whether there is a business state logic conflict caused by multiple nodes concurrently modifying the same highly competitive core transaction. When a business state logic conflict is determined, the data collaboration consensus engine extracts the conflicting abstract data entities into an independent logically isolated running rack, reads the physical transaction causal dependency vector embedded in the qualifier tags of the abstract data entities, and determines the physical causal order between conflicting transactions based on the local logical clock vector snapshot of the physical node at the time of transaction generation and the global version number of the target competitive resource involved in the transaction, which are contained in the physical transaction causal dependency vector. Based on the physical causal order, a nonlinear directed acyclic graph is constructed with each conflicting transaction as a vertex and the causal relationship as a directed edge. Topological sorting is performed on the nonlinear directed acyclic graph, and compensation adjustment instructions for offsetting state deviations are generated in situ based on the sorting results. The compensation adjustment instructions are directly appended to the end of the global distributed ledger as new blocks.
6. The distributed ledger storage method for multi-center clinical trials according to claim 1, characterized in that, Each physical node periodically captures a static topology image of the global distributed ledger consensus convergence point and saves it locally. When the data collaboration consensus engine determines that the current physical node fails to achieve asynchronous alignment due to data fork or data replay attack, the physical node activates the antifragile self-healing program, freezes the current active ledger, and rolls back the overall running state to the latest legal static topology mirror point that is locally solidified and saved. After the rollback is completed, the physical node uses the static topology mirror point as the new source reference and sends a directional traceback request to the other legitimate physical nodes in the distributed storage network. It then pulls the legitimate incremental abstract data entity stream after the mirror point in one direction, completes the discrete replay calculation locally, and reconstructs the sharded ledger in situ.
7. The distributed ledger storage method for multi-center clinical trials according to claim 1, characterized in that, The physical node deploys a data density monitor, which counts the cumulative number of bytes of unaligned abstract data entities in the current discrete ledger storage shard at a frequency of seconds, and establishes the ratio of the cumulative number of bytes to the duration of a preset physical time window as the local storage incremental density index. When the local storage incremental density index exceeds the preset network bandwidth security threshold, the communication gateway reads the real-time idle connection status of the peer consensus node, switches the node-aligned communication link to an adaptive multi-channel parallel cascading mode, and positively adjusts the length of the data transmission frame according to the extent of the network bandwidth security threshold exceedance, compressing the proportion of edge redundancy check bits in the data transmission frame to release physical network bandwidth.
8. A distributed ledger storage device for multi-center clinical trials, characterized in that, include: The data access and conversion module is used to receive write requests initiated by multi-center clinical trial nodes through the front-end data access gateway and convert the write requests into abstract data entities. The local clock binding and mounting module is used to collect the local logical clock vector inside the current physical node through the front-end data access gateway, bind the local logical clock vector to the abstract data entity, control the physical node to mount the abstract data entity to the local discrete ledger storage shard according to the monotonically increasing law of the local logical clock vector, and generate the root hash feature digest; The digest comparison module is used to initiate alignment scheduling to each of the physical nodes based on preset alignment triggering conditions through the data collaborative consensus engine in the distributed storage network, instructing each of the physical nodes to exchange the root hash feature digest, and to complete the literal consistency comparison of the root hash feature digest; The differential reconstruction module is used to trigger the data state differential reconstruction program when the result of the literal consistency comparison indicates that the root hash feature digest between the two physical nodes has deviated, and to control the physical node that initiated the alignment to push the corresponding discrete ledger storage shard to the peer storage node in the form of a non-blocking data stream. The incremental merging module is used to receive the non-blocking data stream through the peer storage node, and use the received sharded chain segments to perform incremental merging on the local global distributed ledger, thereby achieving strong consistency convergence of the global ledger state.
9. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor connected to the memory is configured to execute a computer program stored in the memory to implement the distributed ledger storage method for multicenter clinical trials as described in any one of claims 1 to 7.
10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed, performs the steps of the distributed ledger storage method for multicenter clinical trials as described in any one of claims 1 to 7.
