Context-aware multi-level node trust evaluation and fine-grained empowerment management method and system

Abstract

The application discloses a multi-level node trust evaluation and fine-grained empowerment management method based on context awareness, characterized by collecting interaction event data generated by heterogeneous agents in multiple types of interaction scenes, filtering the interaction event data; extracting trust features of the heterogeneous agents based on the interaction event data; constructing a four-dimensional trust vector according to the trust features; matching a context adapter according to the current interaction scene to calculate a scalar trust score; anchoring the root node of the hash tree to a blockchain smart contract, and comparing and verifying the consistency of the path proof and the on-chain root node by the smart contract or an external verification party to verify the calculation process. The application solves the difficulty in general evaluation and management of the existing blockchain trust mechanism, proposes a multi-level node trust evaluation framework, supports five types of on-chain social relationship scenes, namely C2C, B2C, B2B, G2B and G2C, solves the classification of trust security levels, and realizes fine-grained node empowerment management.

Description

Technical Field

[0001] This invention relates to the fields of blockchain and decentralized information security technology, specifically to a method and system for context-aware multi-level node trust assessment and fine-grained authorization management. Background Technology

[0002] In distributed systems and decentralized environments, trust management is a crucial foundation for mitigating the risks of autonomous interactions. With the proliferation of decentralized ecosystems (including blockchain networks, the Internet of Things, and decentralized autonomous organizations), traditional trust models orchestrated by centralized authorities (CAs) have revealed serious limitations such as single points of failure, domain isolation, and opaque and non-portable reputation mechanisms. Therefore, decentralized trust management (DTM) has become a core primitive of Web3 and the decentralized future.

[0003] Existing trust management systems, such as the early EigenTrust and PeerTrust algorithms, aggregate local trust values ​​into a global reputation score through iterative computation, laying the foundation for simple, homogeneous environments such as file sharing. Subsequently, researchers began to utilize the immutable ledger of blockchains to record trust evidence, proposing a series of trust management frameworks based on verifiable interactions or smart contracts.

[0004] However, existing blockchain reputation systems still suffer from the following major defects: (1) scalar simplification problem, i.e., mainstream models compress the rich and multidimensional nature of trust into a single global scalar (e.g., a score between 0 and 1). This "dimensional collapse" eliminates key nuances. Entities may have high capabilities (technical resources) but exhibit low integrity (continuous honesty). A single score masks such differences, making the system vulnerable to "value imbalance" attacks, i.e., adversarial reputations are cheaply accumulated in one dimension to exploit trust in another dimension; (2) context rigidity problem, trust is inherently subjective and context-dependent. Excellent reputations in casual consumer-to-consumer (C2C) markets cannot logically translate into excellent reputations in formal government-to-business (G2B) markets. (2) Credibility in the regulatory environment: Existing decentralized reputation systems usually adopt a "one-size-fits-all" static algorithm, applying the same evaluation criteria regardless of the nature of the interaction. This lack of context awareness seriously hinders the cross-domain utility and adoption of decentralized identity (DID) systems; (3) Auditability-privacy paradox: Although blockchain provides an immutable ledger, recording fine-grained interaction history on the chain is too costly in terms of transaction fees (Gas) and causes significant data privacy issues. Moving data off-chain enhances privacy but sacrifices verifiability and transparency. The current architecture lacks a practical lightweight mechanism to audit the source of trust scores in an encrypted manner—verifying that they originate from valid interactions—while not exposing sensitive raw transaction data. Summary of the Invention

[0005] To address the shortcomings of existing technologies, the present invention aims to provide a context-aware, multi-level node trust assessment and fine-grained authority management method and system to overcome the aforementioned deficiencies in existing technologies.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] A context-aware, multi-level node trust assessment and fine-grained authority management method includes the following steps:

[0008] Interaction event collection and processing steps: Collect interaction event data generated by heterogeneous agents in multiple interaction scenarios, filter and perform hash operations on the interaction event data to generate event hash values;

[0009] Feature extraction and proof tree construction steps: Extract trust features of the heterogeneous agent based on the interaction event data. The trust features include identity dimension, capability dimension, behavior dimension and reputation dimension; Use the hash values ​​of the events in the same batch as leaf nodes to construct a hash tree;

[0010] Trust vector update and weighted aggregation steps: Construct a four-dimensional trust vector based on the trust features, and update the behavior dimension using a decay mechanism that includes a decay coefficient and a feedback value; Match a context adapter according to the current interaction scenario, assign weights to each dimension of the four-dimensional trust vector through the context adapter and perform weighted aggregation to calculate the scalar trust score;

[0011] On-chain anchoring and audit verification steps: Anchor the root node of the hash tree to the blockchain smart contract, generate a path proof from the leaf node to the root node, and have the smart contract or an external verifier compare and verify the consistency between the path proof and the on-chain root node to verify the calculation process.

[0012] Preferably, in the interaction event collection and processing step, the step of generating the event hash value includes: extracting the proxy identifier, interaction context environment identifier, trust update value, and timestamp information from the interaction event data; concatenating the extracted information; and using an anti-collision hash algorithm to calculate the concatenated data to generate a unique corresponding event hash value.

[0013] Preferably, in the feature extraction and proof tree construction steps, the four types of trust features extracted are determined in the following ways: the identity dimension is generated based on the decentralized identifier and associated verification credentials of the heterogeneous agent on the blockchain; the capability dimension is generated by quantifying the static resources or pledged assets of the heterogeneous agent; the behavior dimension is calculated based on the success rate of historical interaction records; and the reputation dimension is calculated by aggregating peer feedback records and transitive trust paths among network nodes.

[0014] Preferably, in the trust vector update and weighted aggregation steps, the decay mechanism is executed as follows: obtain the historical behavior score of the behavior dimension in the previous time period; determine the decay coefficient that decreases exponentially over time; obtain the feedback value generated by the latest interaction event; multiply the historical behavior score by the decay coefficient and add the feedback value to obtain the latest behavior score for the current time period; and update the behavior dimension in the four-dimensional trust vector using the latest behavior score.

[0015] Preferably, in the trust vector update and weighted aggregation step, the context adapter includes a set of weight matrices pre-configured for multiple interaction scenarios. Each interaction scenario corresponds to a set of weight vectors, and each set of weight vectors includes four weight parameters for identity, ability, behavior, and reputation dimensions, and the sum of the parameters is always one. The target weight vector matching the current interaction scenario is extracted, and the elements of the four-dimensional trust vector are multiplied by the parameters corresponding to the target weight vector to achieve weighted aggregation of each dimension.

[0016] Preferably, in the trust vector update and weighted aggregation step, the step of calculating the scalar trust score includes: after completing the inner product operation of the four-dimensional trust vector and the target weight vector to obtain the aggregation result, introducing a system-preset normalization factor; dividing the aggregation result by the normalization factor, converting the calculation result containing floating-point type into integer form, and generating the final scalar trust score that supports integer arithmetic operations in smart contracts.

[0017] Preferably, in the on-chain anchoring and audit verification steps, the verification process is implemented as follows: obtain the target leaf node corresponding to the computational event to be audited and the path proof generated off-chain, wherein the path proof includes the set of hash values ​​of all adjacent sibling nodes on the path from the target leaf node to the corresponding root node; perform hash calculation based on the target leaf node and the set of hash values ​​of the sibling nodes to generate a verification root node hash; and compare the consistency of the verification root node hash with the root node already anchored on the blockchain.

[0018] Preferably, the execution process of the method is jointly completed by an off-chain engine and an on-chain smart contract: the data collection, feature extraction, vector aggregation calculation, hash tree construction and proof generation steps from the interaction event collection and processing step to the trust vector update and weighted aggregation step are all executed by the off-chain engine in an off-chain environment; the hash tree root node anchoring storage and hash consistency comparison and verification steps of the on-chain anchoring and audit verification steps are all triggered and executed by the smart contract in the blockchain network.

[0019] Preferably, the trust vector construction and update mechanism adopts a dimensional decoupling architecture strategy: at the data structure level, the identity dimension based on decentralized identifier verification and the reputation dimension based on network node peer feedback are set as mutually orthogonal independent dimensions. In the trust score aggregation calculation, the context adapter applies independent weight parameters to the two dimensions respectively, and the decay mechanism updated with time period as the independent variable performs independent calculations in sync.

[0020] A context-aware, multi-layered node trust assessment and fine-grained authorization management system includes:

[0021] The interactive event collection and processing module is used to collect interactive event data generated by heterogeneous agents in multiple interactive scenarios as described in the interactive event collection and processing steps, filter and perform hash operations on the interactive event data, and generate event hash values.

[0022] The feature extraction and proof tree construction module is used to perform the feature extraction and proof tree construction steps as described in the steps of extracting trust features of the heterogeneous agent based on the interaction event data, wherein the trust features include identity, capability, behavior and reputation dimensions; and to construct a hash tree by using the hash values ​​of the events in the same batch as leaf nodes.

[0023] The Trust Vector Update and Weighted Aggregation Module is used to perform the following steps: constructing a four-dimensional trust vector based on the trust features, updating the behavior dimension using a decay mechanism that includes a decay coefficient and a feedback value; matching a context adapter based on the current interaction scenario, assigning weights to each dimension of the four-dimensional trust vector through the context adapter and weighted aggregating the vector to calculate a scalar trust score.

[0024] The on-chain anchoring and audit verification module is used to perform the steps described in the on-chain anchoring and audit verification process, such as anchoring the root node of the hash tree to the blockchain smart contract, generating a path proof from the leaf node to the root node, and having the smart contract or an external verifier compare and verify the consistency between the path proof and the on-chain root node to verify the calculation process.

[0025] The beneficial effects of this invention are as follows: The method of this invention adopts a trust hypercube model, combines multi-dimensional vector decoupling and dynamic context adapters to construct a reputation management model, and incentivizes the model to autonomously optimize the trust path through a verifiable audit mechanism based on Merkle hash trees, triggering a "dimensionality-resistant collapse" effect, enabling it to capture deep trust semantics in heterogeneous social relationship scenarios (such as the decoupling of identity and reputation, and the punishment of malicious nodes by behavior decay). Experimental results show that compared with existing methods (such as EigenTrust and PeerTrust), this invention exhibits significant performance improvements in the accuracy of malicious node identification and resistance to Sybil and On-Off attacks. Furthermore, this invention explores whether context-aware weight configuration has a positive impact on cross-domain generalization. Experiments show that dynamically adjusting the contribution weights of each dimension can directly improve the applicability and accuracy of trust assessment in different interaction scenarios. Attached Figure Description

[0026] Figure 1 A flowchart illustrating a context-aware, multi-level node trust assessment and fine-grained weighting management method provided by this invention.

[0027] Figure 2 This invention provides an overall architecture for a context-aware, multi-layered node trust assessment and fine-grained authority management method. The flowchart illustrates the hybrid off-chain computation and on-chain verification mechanism.

[0028] Figure 3 This invention relates to the change of trust score in step S3 as a function of simulation steps and the detection index. UniTrust maintains consistent discriminative power, while the scalar baseline exhibits convergence.

[0029] Figure 4 This is a comparison chart of the ablation study results of this invention. Detailed Implementation

[0030] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0031] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. The term "and / or" as used herein includes any and all combinations of one or more of the associated listed items.

[0032] The embodiments of the present invention will be further described in detail below with reference to the accompanying drawings:

[0033] This application proposes a context-aware, multi-layered node trust assessment and empowerment management method. The method revolves around interaction event data generated by heterogeneous proxies in various interaction scenarios. Relying on a layered architecture comprised of an off-chain engine and on-chain smart contracts, it completes a closed-loop process from data collection, feature extraction, vector aggregation to on-chain anchoring and audit verification. The heterogeneous proxies refer to various types of node entities participating in interactions in a decentralized network environment, including individual user nodes, enterprise nodes, and government nodes, among other participants with different attributes, varying identity types, resource endowments, and interaction behavior patterns. The resulting interaction data exhibits significant multi-source heterogeneity. In the layered architecture, the off-chain engine is responsible for performing data-intensive computations in the off-chain environment, while the on-chain smart contracts handle lightweight anchoring storage and path proof verification. The two work collaboratively, ensuring computational efficiency while achieving reliable verification of off-chain computation results.

[0034] Specifically, the method includes the following steps: interaction event collection and processing, feature extraction and proof tree construction, trust vector update and weighted aggregation, and on-chain anchoring and audit verification. Each step is executed sequentially, and the output of the preceding step serves as the input for the subsequent step, together forming a complete trust assessment and empowerment management process.

[0035] In the interaction event collection and processing step, interaction event data generated by heterogeneous agents in multiple interaction scenarios are collected. These multiple interaction scenarios cover real-world heterogeneous social relationship types existing in decentralized networks, specifically including C2C (consumer-to-consumer), B2C (merchant-to-consumer), B2B (merchant-to-merchant), G2B (government-to-merchant), and G2C (government-to-citizen) scenarios. These correspond to interaction types with different semantic backgrounds, such as peer-to-peer individual transactions, platform-based retail consumption, inter-enterprise contractual collaboration, administrative supervision and corporate compliance, and government public service provision. The roles, interaction frequencies, and emphasis on trust among participating entities vary in different scenarios, providing a practical basis for the subsequent context-aware weighting mechanism.

[0036] The collected interaction event data is filtered to remove invalid event records caused by network transmission errors, abnormal data formats, or other unsuitable factors, retaining valid data entries that truly reflect the proxy interaction behavior to ensure the input quality for subsequent feature extraction and hash calculation. After filtering, the valid interaction event data is hashed to generate event hash values. The specific execution process of the hash calculation is as follows: the proxy identifier, interaction context environment identifier, trust update value, and timestamp information are extracted from the interaction event data. These four pieces of information are concatenated sequentially, and then a collision-resistant hash algorithm is used to calculate the unique corresponding event hash value. The collision-resistant hash algorithm has computational irreversibility and collision difficulty, and can be implemented using hash functions suitable for blockchain scenarios such as Keccak-256 or Poseidon, to ensure that the hash values ​​generated by different interaction events are different with a very high probability, thereby supporting subsequent unique identification and integrity verification. The above hash calculation can be formally expressed as:

[0037]

[0038] in, The selected anti-collision hash function, For the first The leaf node hash value corresponding to the atomic trust update event. The proxy identifier for initiating or participating in this interaction event. This serves as a context identifier for the scene type to which the interaction event belongs. This represents the trust update value triggered by this interaction event. This is the timestamp when the interaction event occurred. All information is combined into a unique input string through concatenation, then transformed by a hash function to generate a fixed-length event hash value. This value will serve as the basic data unit for constructing the subsequent proof tree.

[0039] After entering the feature extraction and proof tree construction step, the trust features of heterogeneous agents are extracted based on the interaction event data. The trust features include four independent dimensions, namely identity dimension, ability dimension, behavior dimension and reputation dimension, which form the basis for subsequent trust vector modeling.

[0040] The identity dimension is generated based on decentralized identifiers and associated verification credentials of heterogeneous agents on the blockchain. A decentralized identifier is a self-governing identity mechanism conforming to W3C international standards, allowing agent entities to independently register, manage, and prove the validity and legitimacy of their identity to verifiers on the blockchain network without the endorsement of a centralized institution. The identity dimension score reflects the trustworthiness of the agent entity at the identity verification level; the richer the types of verification credentials and the higher the verification level, the larger the identity dimension value. The unforgeability of this dimension stems from the combination of the blockchain's immutability and cryptographic signature mechanisms, making it difficult for false identities to pass verification without incurring high costs, thus reducing the space for malicious nodes to manipulate trust scores by forging identities at the source.

[0041] The capability dimension is generated by quantifying the static resources or pledged assets of heterogeneous agents. Static resources include technical capability indicators such as computing resources, storage resources, and network bandwidth held by the agent node, while pledged assets refer to the economic resources locked by the agent in the contract before participating in the interaction, serving as quantifiable proof of its willingness and ability to perform. The higher the value of the capability dimension, the stronger the objective support for the agent in providing services or fulfilling obligations, which helps to distinguish between trusted nodes with real capabilities and nodes that rely solely on reputation accumulation but lack substantial capabilities.

[0042] The behavioral dimension is calculated based on the success rate of historical interaction records, reflecting the agent's adherence to agreements and honest performance in past interactions. A higher success rate indicates more stable and reliable historical behavior of the agent, resulting in a larger value for the behavioral dimension. It is worth noting that the behavioral dimension is dynamically updated in the trust vector, with its value decaying over time. This decay mechanism will be explained in detail in the subsequent trust vector update steps.

[0043] The reputation dimension is calculated by aggregating peer feedback records and transitive trust paths among network nodes. Peer feedback refers to the subjective evaluations given by other nodes that have directly interacted with the target agent regarding the outcome of their actions. Transitive trust paths allow the feedback from indirectly related nodes to be weighted and accumulated through trust propagation paths, thereby forming a network-level reputation assessment of the target agent. The reputation dimension captures the degree of collective recognition of the agent at the social network level, which is of great significance for measuring the agent's social credit beyond historical interaction accumulation.

[0044] After extracting trust features, the hash values ​​of events in the same batch are used as leaf nodes to construct a hash tree. The hash tree adopts a binary Merkle hash tree structure. Each leaf node stores an event hash value generated by the aforementioned hash operation. Adjacent leaf node hash values ​​are concatenated layer by layer and hashed again, recursively generating intermediate node hash values ​​from the bottom up until a unique root node hash value is calculated. By batch processing event data generated within the same period and organizing it into a single Merkle hash tree, a cryptographic commitment to the integrity of the entire batch of event data can be made in a single on-chain anchoring operation, effectively reducing on-chain storage and transaction fee overhead, while protecting the original interaction data from being exposed to the on-chain public environment.

[0045] After proceeding to the trust vector update and weighted aggregation steps, a four-dimensional trust vector is constructed based on the trust features. This four-dimensional trust vector represents the trust state of agent u at time period t as a vector in a four-dimensional Euclidean space, formally defined as follows:

[0046]

[0047] in, as an agent In the Trust vector for each time period, As an identity dimension, it represents the verification level of an entity's decentralized identifier (DID), verifying the existence and legitimacy of the entity in accordance with the W3C DID specification. as an agent Identity dimension score, In terms of capability, it quantifies static resources or abilities, similar to the belief in "capability" in subjective logic. as an agent Ability dimension score, This is a behavioral dimension, a dynamic indicator reflecting the success rate of historical interactions. This dimension is susceptible to time decay to mitigate "Sleeping Beauty" attacks. as an agent In the The behavioral dimension score for each time period For the reputation dimension, aggregated social beliefs derived from peer feedback are calculated using the trust transmission path. as an agent In the The reputation dimension score is calculated for each time period. The identity and ability dimensions are relatively stable, with minimal changes over time; the behavior and reputation dimensions, however, are dynamically updated based on new interaction events generated within each time period. The values ​​for each dimension are normalized numerical ranges, expressed as integers in the actual implementation to adapt to the on-chain integer arithmetic operation environment of smart contracts.

[0048] The behavioral dimension is updated using a decay mechanism that includes a decay coefficient and a feedback value. This decay mechanism follows the general principle of trust naturally decaying over time in online social networks. Its core logic is that the behavioral reputation accumulated by an agent in the past should not be permanently valid, but should gradually decrease exponentially over time. Simultaneously, the feedback value generated by the latest interaction event is superimposed on the decayed historical score, thus making trust maintenance a continuous requirement. Specifically, the implementation method is as follows: obtain the historical behavioral score of the behavioral dimension in the previous time period, determine the decay coefficient that decreases exponentially over time, obtain the feedback value generated by the latest interaction event, multiply the historical behavioral score by the decay coefficient, add the feedback value, obtain the latest behavioral score for the current time period, and use the latest behavioral score to update the behavioral dimension in the four-dimensional trust vector. The mathematical expression of this decay mechanism is:

[0049]

[0050] in, For the current time period The latest behavioral score, The score represents the historical behavior score from the previous time period. For time intervals The decay coefficient decreases exponentially. A constant parameter for controlling the decay rate. This represents the time interval between the current time period and the previous time period. This is the feedback value generated by the most recent interaction event. Positive feedback corresponds to honest behavior, while negative feedback corresponds to breach of contract or malicious behavior. When the agent is inactive for a period of time... As the score approaches zero, the historically accumulated behavioral score decreases accordingly. When the agent continuously generates positive feedback, the score remains stable at a high level. When the agent defaults or engages in malicious behavior, the negative feedback value causes its behavioral score to drop rapidly. This mechanism effectively curbs the strategy of malicious nodes accumulating high scores in the early stages and launching attacks at critical moments, improving the system's ability to identify intermittent malicious behavior patterns.

[0051] The context adapter is matched based on the current interaction scenario. The context adapter is a pre-configured set of weight matrices for multiple interaction scenarios. Each interaction scenario corresponds to a set of weight vectors. The role of the weight vectors is to assign different contribution weights to each dimension of the four-dimensional trust vector based on the semantic features of the current scenario, thereby achieving scenario-adaptive trust aggregation. Formally, let the supported set of interaction scenarios be denoted as . For any of these scenarios Define the corresponding weight vector Each context adapter contains four weight parameters for the dimensions of identity, ability, behavior, and reputation, and the sum of these parameters is always one. This is to ensure that the weighted aggregation result is within a reasonable numerical range.

[0052] In consumer-to-consumer scenarios, both parties are ordinary individual users, and the interaction outcome primarily relies on the combined endorsement of historical behavior records and social reputation. Therefore, weight allocation focuses on behavioral and reputational dimensions. In merchant-to-merchant scenarios, the core consideration for contract fulfillment between enterprises lies in the other party's resource capabilities and qualifications. Thus, weight allocation focuses on capability. In government-to-citizen and government-to-merchant scenarios, the compliance and traceability of identity are primary prerequisites. Therefore, weight allocation focuses on identity, supplemented by reputation as a secondary reference. Through this scenario-adaptive weight allocation strategy, the same agent can obtain semantically reasonable and scenario-specific differentiated trust scores in different interaction scenarios, avoiding the problem of single scores failing to generalize across heterogeneous scenarios under static weight allocation.

[0053] The context adapter assigns weights to each dimension of the four-dimensional trust vector and performs weighted aggregation to calculate a scalar trust score. Specifically, a target weight vector matching the current interaction scenario is extracted. The elements of the four-dimensional trust vector are then multiplied by the corresponding parameters of the target weight vector to achieve weighted aggregation across dimensions. After the aggregation result is obtained from the multiplication of the four-dimensional trust vector and the target weight vector, a system-preset normalization factor is introduced. The aggregation result is divided by the normalization factor, converting the floating-point calculation result into integer form, generating the final scalar trust score that supports integer arithmetic operations within smart contracts. The formal expression of the above calculation process is as follows:

[0054]

[0055] in, as an agent In the scene Context-aware scalar trust score As the normalization factor, For the scene Dimensions in the corresponding weight vector The weight parameters, as an agent Dimensions in the Trust Vector The current value of the normalization factor. At the implementation level, it is set to 10000 to support on-chain integer arithmetic calculations of smart contracts without introducing floating-point operations, while ensuring that the final trust score is linearly distributed between 0 and 10000, corresponding to an intuitively readable range of 0% to 100%.

[0056] In the construction and updating mechanism of the trust vector, a dimensional decoupling architecture strategy is adopted. At the data structure level, the identity dimension, verified by decentralized identifiers, and the reputation dimension, calculated based on feedback from network node peers, are set as mutually orthogonal and independent dimensions. They are semantically independent; the identity dimension reflects verifiable objective identity facts on the chain, while the reputation dimension reflects the subjective collective evaluation of proxy behavior by the network community. They are neither derived from nor substituted for each other. In the trust score aggregation calculation, independent weight parameters are applied to these two dimensions through a context adapter, and independent calculations are performed simultaneously using a decay mechanism updated with a time period as the independent variable. This orthogonal decoupling design makes it difficult for malicious nodes to inflate the weighted contributions of other dimensions by accumulating a large amount of false reputation on a single dimension, thereby significantly improving the system's resistance to single-dimensional attack strategies and enhancing the robustness and credibility of the overall trust assessment results.

[0057] After entering the on-chain anchoring and audit verification steps, the root node of the hash tree is anchored to the blockchain smart contract. The root node serves as a cryptographic commitment to the entire batch of interaction event data, and its uniqueness and immutability are guaranteed by the underlying consensus mechanism of the blockchain. The on-chain anchoring operation only requires submitting a fixed-length root node hash value and does not involve storing the original interaction data on the chain. Therefore, on-chain storage overhead and transaction fees remain at a low level, exhibiting good cost controllability.

[0058] After anchoring the root node, a path proof from the leaf node to the root node is generated. This path proof is a Merkle path proof, containing the set of hash values ​​of all adjacent sibling nodes along the path from the target leaf node to the corresponding root node. Specifically, the path proof generation process proceeds layer by layer up the Merkle hash tree from the target leaf node towards the root, recording the hash values ​​of sibling nodes under the same parent node at each level, until the root node is reached. The length of the path proof is proportional to the tree height; for a Merkle hash tree with n leaf nodes, the length of the path proof is... This means that the verification complexity increases only logarithmically with the increase of data size, and it has efficient scalability.

[0059] After the path proof is generated, a smart contract or external verifier compares and verifies its consistency with the on-chain root node to verify the computation process. The specific implementation of the verification process is as follows: Obtain the target leaf node corresponding to the computation event to be audited and the off-chain generated path proof. The path proof includes a set of hash values ​​of all adjacent sibling nodes on the path from the target leaf node to the corresponding root node. Perform hash calculations based on the target leaf node and the set of sibling node hash values, reconstructing the path from leaf to root layer by layer to generate a verification root node hash. Compare the verification root node hash with the root node already anchored on the blockchain. If they are the same, it is determined that the trust update event does indeed exist in the off-chain dataset and the computation process has not been tampered with; if they are inconsistent, it is determined that the event data is abnormal, triggering a corresponding audit alarm or operation rejection. The formal expression of this verification mechanism is:

[0060]

[0061] in, To start from the target leaf node The path proof is formed by the set of hash values ​​of sibling nodes on the path to the root node. The target leaf node hash value to be verified. The hash value of the root node already anchored on the blockchain will be output as a boolean value. This indicates that the verification has passed. This indicates that the verification failed.

[0062] The entire method is executed using a layered architecture comprised of an off-chain engine and on-chain smart contracts. The data collection, feature extraction, vector aggregation calculation, hash tree construction, and proof generation steps involved in the interaction event collection and processing steps, up to the trust vector update and weighted aggregation steps, are all executed off-chain by the off-chain engine. This part involves large computational loads and large data volumes, making it unsuitable for direct on-chain execution. Off-chain processing effectively avoids the scalability bottlenecks caused by limited on-chain computing resources and high transaction fees. The hash tree root node anchoring and storage, as well as the hash consistency comparison and verification steps for the input path proof, involved in the on-chain anchoring and audit verification steps, are all triggered and executed by on-chain smart contracts within the blockchain network. The on-chain portion only undertakes lightweight storage and verification responsibilities, with low computational complexity. It can maintain efficient operation under on-chain resource constraints. The core functional modules of smart contracts include an interface for updating and storing trust vectors, an interface for reading context scenario weight configurations, and an audit verification interface for receiving path proofs and executing root node consistency checks. These three types of interfaces jointly support the complete operating logic of the system.

[0063] This application also provides a context-aware, multi-level node trust assessment and authorization management device, including the following functional modules:

[0064] The interaction event collection and processing module is used to collect interaction event data generated by heterogeneous agents in various interaction scenarios, filter and perform hash operations on the interaction event data to generate event hash values. This module transforms multi-source heterogeneous interaction events into a unified format hash digest through preprocessing and hash compression of the original interaction data, providing standardized basic data input for subsequent proof tree construction.

[0065] The feature extraction and proof tree construction module is used to extract trust features of heterogeneous agents based on the interaction event data. These trust features include identity, capability, behavior, and reputation dimensions. The module uses the hash values ​​of events from the same batch as leaf nodes to construct a hash tree. This module completes the transformation from raw interaction data to multi-dimensional trust features and then to a cryptographic commitment structure, providing feature input for trust vector modeling and a verifiable data structure foundation for on-chain auditing.

[0066] The trust vector update and weighted aggregation module is used to construct a four-dimensional trust vector based on the trust features, update the behavior dimension using a decay mechanism that includes a decay coefficient and a feedback value, match a context adapter according to the current interaction scenario, assign weights to each dimension of the four-dimensional trust vector through the context adapter, and perform weighted aggregation to calculate a scalar trust score. This module is the core execution unit of the system's trust evaluation logic. Through the synergistic effect of dimensional decoupling, dynamic decay, and scenario-aware weighting, it generates a final trust score that accurately reflects the semantics of the current interaction scenario.

[0067] The on-chain anchoring and audit verification module is used to anchor the root node of the hash tree to a blockchain smart contract, generate a path proof from the leaf node to the root node, and have the smart contract or an external verifier compare and verify the consistency of the path proof with the on-chain root node to verify the computation process. This module undertakes the core responsibility of ensuring system transparency and trustworthiness, ensuring that off-chain computation results can be independently audited by any verifier without exposing the original data, thus achieving a balance between computational verifiability and data privacy protection.

[0068] The above are merely preferred embodiments of the present invention. The scope of protection of the present invention is not limited to the above embodiments. All technical solutions falling within the scope of the present invention's concept are within the scope of protection of the present invention. It should be noted that for those skilled in the art, any improvements and modifications made without departing from the principle of the present invention should also be considered within the scope of protection of the present invention.

Claims

1. A context-aware, multi-level node trust assessment and fine-grained weighting management method, characterized in that, Includes the following steps: Interaction event collection and processing steps: Collect interaction event data generated by heterogeneous agents in multiple interaction scenarios, and generate event hash values ​​based on the interaction event data; Feature extraction and proof tree construction steps: Extract the trust features of the heterogeneous agent based on the interaction event data. The trust features include identity dimension, capability dimension, behavior dimension and reputation dimension. Use the hash values ​​of the events in the same batch as leaf nodes to construct a hash tree; Trust vector update and weighted aggregation steps: Construct a four-dimensional trust vector based on the trust features, and update the behavior dimension using a decay mechanism that includes a decay coefficient and a feedback value; Match a context adapter according to the current interaction scenario, assign weights to each dimension of the four-dimensional trust vector through the context adapter and perform weighted aggregation to calculate the scalar trust score; On-chain anchoring and audit verification steps: Anchor the root node of the hash tree to the blockchain smart contract, generate a path proof from the leaf node to the root node, and have the smart contract or an external verifier compare and verify the consistency between the path proof and the on-chain root node to verify the calculation process.

2. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, In the interaction event collection and processing steps, the step of generating an event hash value includes: extracting the proxy identifier, interaction context environment identifier, trust update value, and timestamp information from the interaction event data; concatenating the extracted information; and using an anti-collision hash algorithm to calculate the concatenated data to generate a unique corresponding event hash value.

3. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, In the feature extraction and proof tree construction steps, the four types of trust features extracted are specifically determined in the following ways: the identity dimension is generated based on the decentralized identifier and associated verification credentials of the heterogeneous agent on the blockchain; the capability dimension is generated by quantifying the static resources or pledged assets of the heterogeneous agent; the behavior dimension is calculated based on the success rate of historical interaction records; and the reputation dimension is calculated by aggregating peer feedback records and transitive trust paths among network nodes.

4. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, In the trust vector update and weighted aggregation steps, the decay mechanism is executed as follows: obtain the historical behavior score of the behavior dimension in the previous time period; determine the decay coefficient that decreases exponentially over time; obtain the feedback value generated by the latest interaction event; multiply the historical behavior score by the decay coefficient and add the feedback value to obtain the latest behavior score for the current time period; and update the behavior dimension in the four-dimensional trust vector using the latest behavior score.

5. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, In the trust vector update and weighted aggregation step, the context adapter includes a set of weight matrices pre-configured for multiple interaction scenarios. Each interaction scenario corresponds to a set of weight vectors. Each set of weight vectors includes four weight parameters for identity, ability, behavior, and reputation dimensions, and the sum of the parameters is always one. The target weight vector matching the current interaction scenario is extracted, and the elements of the four-dimensional trust vector are multiplied by the parameters corresponding to the target weight vector to achieve weighted aggregation of each dimension.

6. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 5, characterized in that, In the trust vector update and weighted aggregation steps, the step of calculating the scalar trust score includes: after the four-dimensional trust vector and the target weight vector are subjected to inner product operation to obtain the aggregation result, a system-preset normalization factor is introduced; the aggregation result is divided by the normalization factor, and the calculation result containing floating-point type is converted into integer form to generate the final scalar trust score that supports integer arithmetic operations in smart contracts.

7. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, In the on-chain anchoring and audit verification steps, the verification process is implemented as follows: obtain the target leaf node corresponding to the computational event to be audited and the path proof generated off-chain, wherein the path proof includes the set of hash values ​​of all adjacent sibling nodes on the path from the target leaf node to the corresponding root node; perform hash calculation based on the target leaf node and the set of hash values ​​of sibling nodes to generate the verification root node hash; The consistency between the verified root node hash and the root node already anchored on the blockchain is compared.

8. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, The execution process of the method is jointly completed by an off-chain engine and an on-chain smart contract: the data collection, feature extraction, vector aggregation calculation, hash tree construction and proof generation steps from the interaction event collection and processing step to the trust vector update and weighted aggregation step are all executed by the off-chain engine in an off-chain environment; the hash tree root node anchoring storage and hash consistency comparison and verification steps of the on-chain anchoring and audit verification steps are all triggered and executed by the smart contract in the blockchain network.

9. The context-aware multi-level node trust assessment and fine-grained weighting management method according to claim 1, characterized in that, The trust vector construction and update mechanism adopts a dimensional decoupling architecture strategy: at the data structure level, the identity dimension based on decentralized identifier verification and the reputation dimension based on network node peer feedback are set as mutually orthogonal independent dimensions. In the trust score aggregation calculation, the context adapter applies independent weight parameters to the two dimensions respectively, and performs independent calculations in sync with the decay mechanism updated with time period as the independent variable.

10. A context-aware, multi-level node trust assessment and fine-grained authorization management system, characterized in that, include: The interactive event collection and processing module is used to collect interactive event data generated by heterogeneous agents in multiple interactive scenarios as described in the interactive event collection and processing steps, filter and perform hash operations on the interactive event data, and generate event hash values. The feature extraction and proof tree construction module is used to perform the feature extraction and proof tree construction steps as described in the steps of extracting trust features of the heterogeneous agent based on the interaction event data, wherein the trust features include identity, capability, behavior and reputation dimensions; and to construct a hash tree by using the hash values ​​of the events in the same batch as leaf nodes. The Trust Vector Update and Weighted Aggregation Module is used to perform the following steps: constructing a four-dimensional trust vector based on the trust features, updating the behavior dimension using a decay mechanism that includes a decay coefficient and a feedback value; matching a context adapter based on the current interaction scenario, assigning weights to each dimension of the four-dimensional trust vector through the context adapter and weighted aggregating the vector to calculate a scalar trust score. The on-chain anchoring and audit verification module is used to perform the steps described in the on-chain anchoring and audit verification process, such as anchoring the root node of the hash tree to the blockchain smart contract, generating a path proof from the leaf node to the root node, and having the smart contract or an external verifier compare and verify the consistency between the path proof and the on-chain root node to verify the calculation process.

Images