Introduction to the UTU Trust Engine

What it is

The UTU Trust Engine is a revolutionary solution designed to bring a real model of human trust to online platforms, marketplaces, and decentralized applications. By incorporating trust models into digital interactions, the UTU Trust Engine aims to enhance the trustworthiness of transactions and improve the overall user experience when engaging with various services and products online.

Example Use Case

As an example, let’s consider a decentralised exchange (DEX). Many DEXs allow users to load custom token lists or specific token addresses that they got somewhere, like someone on Twitter or Telegram. However, users have no way of knowing if these tokens are legitimate or if they are being scammed. The UTU Trust Engine can help by providing relevant feedback to users about the tokens they are trading. Specifically, the UTU Trust Engine can provide feedback such as: “Your contacts Alice and Bob trust this specific ERC-20 token.” UTU can also provide more nuanced information, such as: “Your fellow traders Alice and Bob trust this ERC-20 token, and they have frequently traded it on this exchange.”

Documentation Outline

The rest of this document is structured as follows:

  • In the rest of this chapter, we introduce the main ideas, architecture, and concepts of the UTU Trust Engine.

  • In chapter How to Integrate, we describe how to integrate UTU into your app.

  • In chapter How to Contribute, we describe how to contribute extensions and bug fixes to the UTU Trust Engine, often for rewards.

Serving Relevant Feedback

To serve relevant feedback, UTU’s Trust Engine considers social connections between users, the tokens they trade, and pertinent context data. In the above example, the trust analyser determines that:

  1. Alice and Bob are connected to the currently signed-in user.

  2. They have traded the specific ERC-20 token in the past on the same exchange.

For this to function, UTU’s API and SDK provide appropriate endpoints and UI components to gather this data. Data is stored in UTU’s shared global database, adhering to strict access controls. Users must permit their data to be used for feedback purposes and have control over how it is utilized.


The UTU Trust Engine is composed of these main components:

  1. Backend API: A centralised backend that offers endpoints for creating and managing entities, relationships between entities, and feedback. The API also provides endpoints for users to access feedback summaries and details about entities from other users who are related to them, either directly or indirectly.

  2. Web SDK: A comprehensive software development kit that provides user-friendly UI elements for viewing and creating staked endorsements and other feedback.

  3. UTU Trust Token (UTT): A blockchain-based smart contract that enables users to endorse entities and earn rewards through a transparent and independently verifiable process. The functionality of the smart contract and its tokenomics is described in detail in the UTU Whitepaper.

  4. UTU App and social media connector: This enables users to connect with social networks in order to show more relevant feedback to them from their own network.

  5. Blockchain transaction scanner: Connected user addresses are scanned for transactions with other users’ addresses as well as smart contracts, to further extend the user’s network and identify which smart contracts have been used by other users in it.

Here is a diagram of the main components, including the user’s browser running the UTU Browser Extension or decentralized apps that integrate UTU:

   !include ../utu-theme.puml

   actor User As user

   usecase "Connect social media" As connect
   usecase "See feedback summaries" As summaries
   usecase "See feedback details" As details
   usecase Endorse
   usecase "Give feedback" As feedback

   card "User's browser" As browser {
       package "Integrating App" As app {
           [UTU SDK] As sdk

       package "UTU Wallet app" As wallet {
           [Connect to earn] As c2e

   cloud "EVM" {
       component "UTU Trust Token contract" As utt

   cloud "Cloud" As Cloud {

     folder "UTU Backend" As backend {
          node "Custom Chainlink oracle node" As oracle

          node "UTU Trust API" As api

          database "Graph Database"

          node "Social media connector" As smc

     collections "Social Media and (D)ID Platforms" as scp
     note right of scp
        Current: Telegram
        Furture: Discord? BrightID? Worldcoin? X?
     end note

   connect -[hidden]right-> summaries
   summaries -[hidden]right-> details
   details -[hidden]right-> Endorse
   Endorse -[hidden]right-> feedback

   connect -[hidden]--> browser
   browser -[hidden]-> EVM
   EVM -[hidden]--> Cloud

   backend -[hidden]down---> scp

   user --> connect
   user --> Endorse
   user --> feedback
   user --> summaries
   user --> details

   connect -> c2e
   c2e --> smc : invoke
   smc -> api : inform about\n relationships
   smc -> utt : inform about\n connections

   Endorse -> sdk
   feedback -> sdk
   summaries -> sdk
   details -> sdk

   sdk --> utt : endorse
   sdk --> api : get or post\nfeedback

   utt ---> oracle : fetch previous Endorsers
   api <- oracle : endorsement
   api --> "Graph Database"

   smc -> scp : get contacts

UTU Trust Engine Main Components

As you can see, the UTU Trust Token (UTT) smart contract ensures transparency and verifiability for entity endorsements.

Main Concepts

The UTU Trust Engine uses the following core concepts:

  • Entities are the main objects of the UTU Trust Engine. They can be users, products, services, or any other object that can provide feedback and/or be reviewed. Each entity has

    • a type, which can be freely determined by using applications,

    • a UUID (universally unique identifier) in the format of an Ethereum address [1],

    • a name and

    • optionally an image link.

  • Relationships are connections between a source and a target entity, and they can be uni- or bi-directional. They further have one of a few different supported types, the most important ones being:

    • social: the two entities represent two persons who are socially related;

    • endorsement: the source endorsed the target (on-chain);

    • feedback: the source provided feedback about the target;

    • interaction: the source interacted with the target, for example by sending them some blockchain tokens.

  • Feedback items are the contents of provided feedback about a target entity, including endorsements and their staked UTU Trust Tokens (UTT).

  • Feedback summary is a summarised view (currently a short text) of a set of feedback items about a target entity.

  • Ranking is an ordering of a given set of entities relative to each other, as interpreted by the UTU Trust Engine based on feedback from the network of the user who requested the ranking. It is important to note that UTU does _not_ assign a global “trust score” or “trust value” to any entity, but rather aims to provide relevant feedback, both in summary and in detail, from the requesting user’s own network. Therefore, a global (objective) ranking of entities does not exist.