因此，如果节点A在信任图实例中与节点B之间存在路径，则节点A被节点B信任。证书的选择是主观的，由节点所有者根据根的选择和最大链长度进行定义。目前，对于一般情况还没有默认的指标。

撤销 是一种密码学关系，表示节点A认为节点C是恶意或不可靠的。例如，包含从A到C路径的所有链都不会被视为有效。因此，如果A信任节点B，B信任节点C，那么节点A对C的间接信任将不存在，否则会存在。

每个节点都有一个 权重。权重表示2的幂或零。如果没有从任何根到节点的路径，给定撤销，其权重为零。离根越近，权重越大。权重也是主观的，并在局部信任图范围内相关。

信任图是内置的，意味着每个节点都捆绑了一个信任图实例和预定义的证书。

从密码学关系的角度来看，信任是传递的。另一方面，由于根的选择，每个网络参与者的信任和证书子集是主观的。

如何在Aqua中使用它

如何导入

import "@fluencelabs/trust-graph/trust-graph-api.aqua"
import "@fluencelabs/trust-graph/trust-graph.aqua"

func my_function(peer_id: string) -> u32:
   on HOST_PEER_ID:
       result <- get_weight(peer_id)
   <- result

如何添加根

• set_root(peer_id:PeerId,max_chain_len: u32) ->SetRootResult
• add_root_trust(node:PeerId,peer_id:PeerId,max_chain_len: u32) -> ?Error

让我们在我们的中继上设置我们的节点ID作为根并添加自签名的信任

func set_me_as_root(max_chain_len):
  result <- add_root_trust(HOST_PEER_ID, INIT_PEER_ID, max_chain_len)

  -- if you use peer_id different from INIT_PEER_ID
  -- you should add keypair in your Sig service
  if result.success:
     -- do smth
     Op.noop()
  else:
     -- handle failure
     Op.noop()

• 您也可以使用 set_root + add_trust 来实现相同的目标
• 如何将密钥对添加到Sig服务
• 只有服务所有者可以添加根
• max_chain_len 指定根链中的信任数量。对于只包含根信任的链，为零。

如何颁发和添加信任

• issue_trust(issuer:PeerId,issued_for:PeerId,expires_at_sec: u64) -> ?Trust, ?Error
• import_trust(trust:Trust,issuer:PeerId) -> ?Error
• add_trust(node:PeerId,issuer:PeerId,issued_for:PeerId,expires_at_sec: u64) -> ?Error

让我们颁发信任，并将其导入我们的中继

func issue_trust_by_me(issued_for: PeerId, expires_at_sec: u64):
  trust, error <- issue_trust(INIT_PEER_ID, issued_for, expires_at_sec)
  if trust == nil:
     -- handle failure
     Op.noop()
  else:
     on HOST_PEER_ID:
        error <- import_trust(trust!, INIT_PEER_ID)
        -- handle error

• add_trust 是 issue_trust 和 import_trust 的组合
• 如果您想通过不是 INIT_PEER_ID 来发行信任，请查看 Sig 服务 文档

如何撤销信任

• issue_revocation(revoked_by:PeerId,revoked:PeerId) -> ?撤销, ?Error
• import_revocation(revocation:撤销) -> ?Error
• revoke(node:PeerId,revoked_by:PeerId,revoked:PeerId) -> ?Error

让我们通过我们的 peer id 撤销一些 peer

func revoke_peer(revoked: PeerId):
  revocation, error <- issue_revocation(INIT_PEER_ID, revoked)
  if revocation == nil:
     -- handle failure
     Op.noop()
  else:
     on HOST_PEER_ID:
        error <- import_revocation(revocation!)
        -- handle error

• revoke 是 issue_revocation 和 import_revocation 的组合
• 如果您想通过不是 INIT_PEER_ID 来发行撤销，请查看 Sig 服务 文档

如何获取证书

• get_all_certs(issued_for:PeerId) ->AllCertsResult
• get_all_certs_from(issued_for:PeerId,issuer:PeerId) ->AllCertsResult
• get_host_certs() ->AllCertsResult
• get_host_certs_from(issuer:PeerId) ->AllCertsResult

让我们获取我们发行给我们的中继 peer id (HOST_PEER_ID) 的所有证书

func get_certs_issued_by_me() -> AllCertsResult:
  on HOST_PEER_ID:
     result <- get_host_certs_from(INIT_PEER_ID)
  <- result

• get_host_certs 只是 get_all_certs(HOST_PEER_ID) 的别名
• _from 调用结果只包含由 issuer 发行的证书

如何获取权重

• get_weight(peer_id:PeerId) ->WeightResult
• get_weight_from(peer_id:PeerId,issuer:PeerId) ->WeightResult

让我们获取我们的中继的信任证书的权重

func get_our_weight() -> ?u32, ?string:
  weight: ?u32
  error: ?string
  on HOST_PEER_ID:
     result <- get_weight_from(INIT_PEER_ID, HOST_PEER_ID)
     if result.success:
        weight <<- result.weight
     else:
        error <<- result.error
  <- weight, error

• get_weight 返回所有证书的结果，而 get_weight_from 只返回由发行者发行的包含信任的证书

如何在TS/JS中使用它

1. 如 Aqua 文档 中所述，添加 export.aqua

2. 将以下内容添加到您的依赖项中

   • @fluencelabs/trust-graph
   • @fluencelabs/aqua
   • @fluencelabs/aqua-lib
   • @fluencelabs/fluence
   • @fluencelabs/fluence-network-environment

3. 导入依赖项

import * as tg from "./generated/export";
import { Fluence, KeyPair } from "@fluencelabs/fluence";
import { krasnodar, Node } from "@fluencelabs/fluence-network-environment";

4. 创建一个客户端（如果您是节点所有者，请指定密钥对 链接）

await Fluence.start({ connectTo: relay /*, KeyPair: builtins_keypair*/});

5. 添加根并发行根信任

let peer_id = Fluence.getStatus().peerId;
let relay = Fluence.getStatus().relayPeerId;
assert(peer_id !== null);
assert(relay !== null);
let max_chain_len = 2;
let far_future = 99999999999999;
let error = await tg.add_root_trust(relay, peer_id, max_chain_len, far_future);
if (error !== null) {
 console.log(error);
}

6. 默认情况下，使用客户端的私钥签名信任/撤销。要使用不同的密钥签名，请参阅 Sig 服务 文档。

// issue signed trust
let error = await tg.issue_trust(relay, peer_id, issued_for_peer_id, expires_at_sec);
if (error !== null) {
 console.log(error);
}

用例

创建一个可信子网络

您可以使用您选择的或选择的指标组织一个子网络，其中包含受信任的 peer。因此，您可以像处理 peer（或密钥）给出的信任一样处理信任。

让我们考虑我们有 peer A、B 和 C

• 选择 peer A 作为权威机构，将其设置为所有 peer 的本地 TrustGraph 的根
• 发行并由 peer A 自签名的信任作为根信任
• 由 peer A 向 peer B 和 peer C 发行信任，并将它们放置在所有 peer 上
• 因此，对于调用 get_weight_from(targetPeer, peerA) 将反映目标 peer 是否在子网络 ABC 中

服务权限管理

您可以在运行时指定谁可以基于本地 TrustGraph（证书、权重）访问服务功能。根据 四元组 检查证明的来源。例如，只有具有非零权重的 peer 才能执行服务函数 trusted_call(weight: WeightResult) -> u8。

...
weight_result <- get_weight(INIT_PEER_ID)
result <- MyService.trusted_call(weight_result)
...

func grant_access(issued_for: PeerId, expires_at_sec: u64):
  error <- add_trust(INIT_PEER_ID, issued_for, expires_at_sec)
  if error != nil
     -- handle error