Trust Base Discovery and Minimization

How to generate and discover trust specifications for transactions

The transaction structure allows for specifying a list of trust dependencies. Initially, various system components will specify these dependencies. For example, a front-end app might specify a version of GETH for evaluating the transaction, a specific version of the Solidity compiler for smart contract execution, or both. Upper layers (like Sequencers) may infer or discover other dependencies, but these will not be part of USL. USL will assume that the Trust Base of a transaction, included as data in the transaction itself, is the intended Trust Base provided by the contributing components in the upper layers.

Therefore, USL won’t concern itself with the following:

  • Discovering the Trust Base of a transaction lacking trust dependency specifications. However, USL might update the given transaction’s trust assumptions based on different criteria.

  • Quantifying trust or calculating a score for a given Trust Base. This will be done off-chain, outside of USL, and might only be used in future USL iterations.

  • Improving trust scores or levels or enforcing certain trust scores, particularly not in the first few product iterations.

For the initial prototype and MVP, we will focus on Trust Base validation. At a minimum, we will need to specify:

  • How a transaction will include trust assumptions (transaction format).

  • An initial set of entities that may appear in the Trust Base of a transaction.

  • A mechanism to store, retrieve, and update this information (off-chain).

In the long run, we may need:

  • A broader definition of trust and trusted entities.

  • A mechanism to calculate the Trust Base of a transaction.

  • A meaningful trust quantification mechanism that allows us to:

    • Assign trust values to entities.

    • Aggregate trust values (for compositions of entities).

    • Compare the trustworthiness of different entities and Trust Bases.

Last updated