chore: release master (#99)

Fix update in rust-peer-distro

.github/actionlint.yaml

@@ -0,0 +1,3 @@
+self-hosted-runner:
+  labels:
+    - builder

.github/download_marine.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-set -o pipefail -o errexit -o nounset
-set -x
-
-MARINE_RELEASE="https://api.github.com/repos/fluencelabs/marine/releases/latest"
-OUT_DIR=~/.bin
-
-# get metadata about release
-curl -s -H "Accept: application/vnd.github.v3+json" $MARINE_RELEASE |
-    # extract url and name for asset with name "marine"
-    # also append $OUT_DIR to each name so file is saved to $OUT_DIR
-    jq -r ".assets | .[] | select(.name == \"marine\") | \"\(.browser_download_url) $OUT_DIR/\(.name)\"" |
-    # download assets
-    xargs -n2 bash -c 'curl -L $0 -o $1 && chmod +x $1'

.github/release-please/config.json

@@ -0,0 +1,36 @@
+{
+  "boostrap-sha": "015422efcce41530a6cd84a25091598bc459d2e6",
+  "release-type": "rust",
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": true,
+  "plugins": [
+    {
+      "type": "cargo-workspace",
+      "merge": false
+    },
+    {
+      "type": "linked-versions",
+      "groupName": "trust-graph, wasm and api",
+      "components": [
+        "trust-graph",
+        "trust-graph-api",
+        "trust-graph-wasm"
+      ]
+    }
+  ],
+  "packages": {
+    "trust-graph": {
+      "component": "trust-graph"
+    },
+    "aqua": {
+      "release-type": "node",
+      "component": "trust-graph-api"
+    },
+    "service": {
+      "component": "trust-graph-wasm"
+    },
+    "keypair": {
+      "component": "keypair"
+    }
+  }
+}

.github/release-please/manifest.json

@@ -0,0 +1,6 @@
+{
+  "trust-graph": "0.4.4",
+  "aqua": "0.4.4",
+  "service": "0.4.4",
+  "keypair": "0.10.1"
+}

.github/renovate.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base",
+    ":semanticCommitTypeAll(chore)"
+  ],
+  "enabledManagers": ["cargo", "npm", "github-actions", "pip_requirements"],
+  "rangeStrategy": "pin",
+  "schedule": "every weekend",
+  "packageRules": [
+    {
+      "matchManagers": ["cargo", "npm"],
+      "matchPackagePatterns": [
+        "@fluencelabs/.*",
+        "fluence-.*",
+        "marine-.*"
+      ],
+      "semanticCommitType": "fix",
+      "semanticCommitScope": "deps",
+      "schedule": "at any time"
+    },
+    {
+      "matchDepTypes": ["devDependencies"],
+      "prPriority": -1,
+      "semanticCommitType": "chore",
+      "semanticCommitScope": "deps"
+    },
+    {
+      "matchUpdateTypes": ["major"],
+      "prConcurrentLimit": 1
+    },
+    {
+      "matchManagers": ["github-actions"],
+      "groupName": "all github-actions",
+      "prPriority": -1
+    }
+  ]
+}

.github/workflows/changelog_config.json

@@ -1,6 +0,0 @@
-{
-    "template": "## Changes since ${{FROM_TAG}}\n\n${{CHANGELOG}}\n\n${{UNCATEGORIZED}}",
-    "pr_template": "- #${{NUMBER}} ${{TITLE}}",
-    "empty_template": "## No changes since ${{FROM_TAG}}",
-    "sort": "DESC"
-}

.github/workflows/lint.yml

@@ -0,0 +1,35 @@
+name: lint
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  pr:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  reviewdog:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Lint actions
+        uses: reviewdog/action-actionlint@v1
+        env:
+          SHELLCHECK_OPTS: "-e SC2086 -e SC2207 -e SC2128"
+        with:
+          reporter: github-pr-check
+          fail_on_error: true

.github/workflows/release.yml

@@ -1,166 +1,193 @@
-name: "publish-release"
+name: "release"
 
 on:
   push:
-    tags:
-      - "v*"
+    branches:
+      - "master"
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
 
 jobs:
-  release:
-    name: "Publish"
-    runs-on: builder
-    container: rust
-    defaults:
-      run:
-        shell: bash
+  release-please:
+    runs-on: ubuntu-latest
+
+    outputs:
+      releases-created: ${{ steps.release.outputs['releases_created'] }}
+      trust-graph-api-release-created: ${{ steps.release.outputs['aqua--release_created'] }}
+      trust-graph-release-created: ${{ steps.release.outputs['trust-graph--release_created'] }}
+      trust-graph-tag-name: ${{ steps.release.outputs['trust-graph--tag_name'] }}
+      trust-graph-version: ${{ steps.release.outputs['trust-graph--version'] }}
 
     steps:
-### Setup
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Set env
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-
-      - name: Download jq
-        run: |
-          curl -L https://github.com/stedolan/jq/releases/download/jq-1.5/jq-linux64 -o /usr/local/bin/jq
-          chmod +x /usr/local/bin/jq
-
-      - name: Download marine
-        run: bash $GITHUB_WORKSPACE/.github/download_marine.sh
-
-      - uses: actions/setup-java@v2
-        with:
-          distribution: 'adopt'
-          java-version: '11'
-
-      - name: Cache npm
-        uses: actions/cache@v2
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-v03-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-v03-
-
-      - uses: actions/setup-node@v2
-        with:
-          node-version: "15"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Cache cargo
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            ~/.cargo/bin
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Install Rust
-        working-directory: ./service
-        run: |
-          rustup toolchain install nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup default nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup override set nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup target add wasm32-wasi --toolchain nightly-2022-01-16-x86_64-unknown-linux-gnu
-
-### Build
-      - name: Build trust-graph
-        working-directory: ./service
-        run: ./build.sh
-
-      - name: Check Aqua compiles
-        working-directory: ./aqua
-        run: |
-          npm i
-          npm run build
-
-      - name: Create distribution package
-        run: |
-          ./builtin-package/package.sh
-
-      - name: Build Changelog
-        id: changelog
-        uses: mikepenz/release-changelog-builder-action@v1
-        with:
-          configuration: ".github/workflows/changelog_config.json"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-### Publish
-      - name: Release to GitHub
+      - name: Run release-please
         id: release
+        uses: google-github-actions/release-please-action@v3
+        with:
+          token: ${{ secrets.FLUENCEBOT_RELEASE_PLEASE_PAT }}
+          command: manifest
+          config-file: .github/release-please/config.json
+          manifest-file: .github/release-please/manifest.json
+
+      - name: Show output from release-please
+        if: steps.release.outputs.releases_created
+        env:
+          RELEASE_PLEASE_OUTPUT: ${{ toJSON(steps.release.outputs) }}
+        run: echo "${RELEASE_PLEASE_OUTPUT}" | jq
+
+  publish:
+    runs-on: builder
+
+    needs: release-please
+    if: needs.release-please.outputs.releases-created
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Import secrets
+        uses: hashicorp/vault-action@v2.4.3
+        with:
+          url: https://vault.fluence.dev
+          path: jwt/github
+          role: ci
+          method: jwt
+          jwtGithubAudience: "https://github.com/fluencelabs"
+          jwtTtl: 300
+          exportToken: false
+          secrets: |
+            kv/npmjs/fluencebot token | NODE_AUTH_TOKEN ;
+            kv/crates.io/fluencebot token | CARGO_REGISTRY_TOKEN
+
+      - name: Setup Rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Setup marine
+        uses: fluencelabs/setup-marine@v1
+
+      - name: Build
+        run: ./build.sh
+        working-directory: service
+
+      - name: Install cargo-workspaces
+        uses: baptiste0928/cargo-install@v1.3.0
+        with:
+          crate: cargo-workspaces
+
+      - name: Publish to crates.io
+        run: |
+          cargo ws publish \
+            --no-git-commit \
+            --allow-dirty \
+            --from-git \
+            --skip-published \
+            --yes
+
+      - name: Setup node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "16"
+          registry-url: "https://registry.npmjs.org"
+          cache-dependency-path: "aqua/package-lock.json"
+          cache: "npm"
+
+      - run: npm i
+        working-directory: aqua
+
+      - run: npm run build
+        working-directory: aqua
+
+      - name: Publish to NPM registry
+        if: needs.release-please.outputs.trust-graph-api-release-created
+        run: npm publish --access public
+        working-directory: aqua
+
+      - name: Install ipfs
+        uses: nahsi/setup-ipfs@v1
+
+      - name: Create builtin distribution package
+        if: needs.release-please.outputs.trust-graph-release-created
+        run: ./builtin-package/package.sh
+
+      - name: Calculate SHA256
+        if: needs.release-please.outputs.trust-graph-release-created
+        id: sha
+        run: |
+          # Calculate sha256
+          du -hs trust-graph.tar.gz
+          sha256sum trust-graph.tar.gz
+          sha=($(sha256sum trust-graph.tar.gz))
+          echo "sha256=${sha}" >> $GITHUB_OUTPUT
+
+      - name: Upload trust-graph package
+        if: needs.release-please.outputs.trust-graph-release-created
         uses: softprops/action-gh-release@v1
         with:
-          name: trust-graph ${{ env.RELEASE_VERSION }}
-          tag_name: ${{ env.RELEASE_VERSION }}
-          files: |
-            ./trust-graph.tar.gz
-          body: ${{steps.changelog.outputs.changelog}}
-          draft: false
-          prerelease: false
-          fail_on_unmatched_files: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-    ### Publish Aqua API
-      - name: Publish Aqua API to NPM
-        run: |
-          npm version ${{ env.RELEASE_VERSION }}
-          npm publish --access public
-        env:
-            NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        working-directory: ./aqua
-
-## Update node-distro repo
-      - name: Calculate SHA256
-        run: |
-            du -hs trust-graph.tar.gz
-            echo $(sha256sum trust-graph.tar.gz)
-            echo "SHA256=$(sha256sum trust-graph.tar.gz | awk '{ print $1 }')" >> $GITHUB_ENV
-
-      - name: Get tar.gz URL
-        id: package-url
-        uses: actions/github-script@v4
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          result-encoding: string
-          script: |
-            try {
-                let assets = await github.repos.listReleaseAssets({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  release_id: "${{ steps.release.outputs.id }}",
-                });
-                console.dir(assets);
-                let package = assets.data.find((a) => a.name === 'trust-graph.tar.gz');
-                let url = package.browser_download_url;
-                console.log("URL: " + url);
-                return url;
-            } catch (e) {
-              console.log("Err: " + e);
-              throw e;
-            }
+          files: trust-graph.tar.gz
+          tag_name: ${{ needs.release-please.outputs.trust-graph-tag-name }}
 
       - name: Update version in node-distro repo
+        if: needs.release-please.outputs.trust-graph-release-created
         uses: benc-uk/workflow-dispatch@v1
         with:
           workflow: update_service
           repo: fluencelabs/node-distro
-          ref: 'main'
+          ref: "main"
           token: ${{ secrets.PERSONAL_TOKEN }}
           inputs: '{
             "name": "trust-graph",
-            "version": "${{ env.RELEASE_VERSION }}",
-            "url": "${{ steps.package-url.outputs.result }}",
-            "sha256": "${{ env.SHA256 }}"
+            "version": "${{ needs.release-please.outputs.trust-graph-version }}",
+            "url": "https://github.com/fluencelabs/trust-graph/releases/download/${{ needs.release-please.outputs.trust-graph-tag-name }}/trust-graph.tar.gz",
+            "sha256": "${{ steps.sha.outputs.sha256 }}"
           }'
 
-      - name: Log notice
-        uses: actions/github-script@v4
+  slack:
+    if: always()
+    name: "Notify"
+    runs-on: ubuntu-latest
+
+    needs:
+      - release-please
+      - publish
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - uses: lwhiteley/dependent-jobs-result-check@v1
+        id: status
         with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-              console.dir(core);
-              core.info("trust-graph was updated to ${{ env.RELEASE_VERSION }} in node-distro repo");
+          statuses: failure
+          dependencies: ${{ toJSON(needs) }}
+
+      - name: Log output
+        run: |
+          echo "statuses:" "${{ steps.status.outputs.statuses }}"
+          echo "jobs:" "${{ steps.status.outputs.jobs }}"
+          echo "found any?:" "${{ steps.status.outputs.found }}"
+
+      - name: Import secrets
+        uses: hashicorp/vault-action@v2.4.3
+        with:
+          url: https://vault.fluence.dev
+          path: jwt/github
+          role: ci
+          method: jwt
+          jwtGithubAudience: "https://github.com/fluencelabs"
+          jwtTtl: 300
+          exportToken: false
+          secrets: |
+            kv/slack/release-please webhook | SLACK_WEBHOOK_URL
+
+      - uses: ravsamhq/notify-slack-action@v2
+        if: steps.status.outputs.found == 'true'
+        with:
+          status: "failure"
+          notification_title: "*{workflow}* has {status_message}"
+          message_format: "${{ steps.status.outputs.jobs }} {status_message} in <{repo_url}|{repo}>"
+          footer: "<{run_url}>"

.github/workflows/run-tests.yml

@@ -0,0 +1,35 @@
+name: Run tests
+
+on:
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+  push:
+    branches:
+      - "master"
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  trust-graph:
+    uses: ./.github/workflows/tests.yml
+
+  lints:
+    name: lints
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Run cargo fmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check

.github/workflows/rust_ci.yml

@@ -1,89 +0,0 @@
-name: Rust CI
-on:
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: "${{ github.workflow }}-${{ github.ref }}"
-  cancel-in-progress: true
-
-jobs:
-  check:
-    name: cargo nextest
-    runs-on: builder
-    container: rust
-    defaults:
-      run:
-        working-directory: service
-        shell: bash
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v2
-
-      - uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - run: mkdir -p ~/.bin
-      - run: echo "~/.bin" >> $GITHUB_PATH
-
-      - name: Install Rust
-        working-directory: ./service
-        run: |
-          rustup toolchain install nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup default nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup override set nightly-2022-01-16-x86_64-unknown-linux-gnu
-          rustup target add wasm32-wasi --toolchain nightly-2022-01-16-x86_64-unknown-linux-gnu
-
-      - name: Download jq
-        run: |
-          curl -L https://github.com/stedolan/jq/releases/download/jq-1.5/jq-linux64 -o ~/.bin/jq
-          chmod +x ~/.bin/jq
-
-      - name: Download marine
-        run: bash $GITHUB_WORKSPACE/.github/download_marine.sh
-
-      - name: Build
-        run: ./build.sh
-
-      - run: cargo install --locked cargo-nextest --version 0.9.22
-      - run: cargo nextest run --release --all-features --no-fail-fast --retries 10 --test-threads 10
-
-  lints:
-    name: Lints
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v2
-
-      - uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Install toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-          override: true
-          components: rustfmt, clippy
-
-      - name: Run cargo fmt
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Run cargo clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -Z unstable-options --all
-        continue-on-error: true # do not fail for now

.github/workflows/tag.yml

@@ -1,25 +0,0 @@
-name: "tag"
-
-on:
-  workflow_dispatch:
-
-jobs:
-  tag:
-    name: "Tag"
-    runs-on: "ubuntu-latest"
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Get branch
-        run: |
-          BRANCH=${GITHUB_REF#refs/*/}
-          SANITIZED=$(echo "$BRANCH" | sed -e 's/[^a-zA-Z0-9-]/-/g')
-          echo "BRANCH=$SANITIZED" >> $GITHUB_ENV
-
-      - name: Bump version and push tag
-        id: tag_version
-        uses: mathieudutour/github-tag-action@v5.5
-        with:
-          append_to_pre_release_tag: ${{ env.BRANCH }}
-          github_token: ${{ secrets.PERSONAL_TOKEN }}

.github/workflows/tests.yml

@@ -0,0 +1,71 @@
+name: Run tests with workflow_call
+
+on:
+  workflow_call:
+
+jobs:
+  trust-graph:
+    name: "cargo nextest"
+    runs-on: builder
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Setup marine
+        uses: fluencelabs/setup-marine@v1
+
+      - name: Build
+        working-directory: ./service
+        run: ./build.sh
+
+      - name: Run cargo clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: -Z unstable-options --all
+
+      - name: Install cargo-nextest
+        uses: baptiste0928/cargo-install@v1.3.0
+        with:
+          crate: cargo-nextest
+          version: 0.9.22
+
+      - name: Run cargo nextest
+        env:
+          NEXTEST_RETRIES: 10
+          NEXTEST_TEST_THREADS: 10
+        run: cargo nextest run --release --all-features --no-fail-fast
+
+      - name: Setup node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "16"
+          registry-url: "https://registry.npmjs.org"
+          cache-dependency-path: "aqua/package-lock.json"
+          cache: "npm"
+
+      - run: npm i
+        working-directory: aqua
+
+      - run: npm run build
+        working-directory: aqua
+
+      - name: Install ipfs
+        uses: nahsi/setup-ipfs@v1
+
+      - name: Create distribution package
+        run: ./builtin-package/package.sh
+
+      - name: Upload trust-graph
+        uses: actions/upload-artifact@v3
+        with:
+          name: trust-graph
+          path: trust-graph.tar.gz

.gitignore

@@ -18,3 +18,12 @@ admin/src/generated/**
 admin/generated/**
 
 target
+
+# recommended by Fluence Labs:
+.idea
+.DS_Store
+.fluence
+Cargo.lock
+**/target/
+.vscode/settings.json
+.repl_history

Cargo.toml

@@ -1,32 +1,9 @@
-[package]
-name = "trust-graph"
-version = "0.3.0"
-authors = ["Fluence Labs"]
-edition = "2018"
-description = "trust graph"
-license = "Apache-2.0"
-repository = "https://github.com/fluencelabs/trust-graph"
-
-[dependencies]
-libp2p-core = { version = "0.31", default-features = false, features = [ "secp256k1" ] }
-serde = { version = "1.0.118", features = ["derive"] }
-
-fluence-keypair = { path = "./keypair", version = "0.6.0" }
-serde_json = "1.0.58"
-bs58 = "0.3.1"
-failure = "0.1.6"
-log = "0.4.11"
-ref-cast = "1.0.2"
-derivative = "2.1.1"
-signature = "1.3.0"
-serde_with = "1.6.0"
-thiserror = "1.0.23"
-sha2 = "0.9.5"
-rand = "0.7.0"
-nonempty = "0.7.0"
-
 [workspace]
 members = [
+    "trust-graph",
     "keypair",
     "service"
 ]
+
+[workspace.dependencies]
+libp2p-identity = { version = "0.1.0", default-features = false, features = ["peerid", "rsa", "ed25519", "secp256k1", "multihash"] }

README.md

@@ -1,20 +1,303 @@
 # Trust Graph
 
-Trust Graph is network-wide peer relationship layer. It's designed to be used to prioritize resources and control permissions in open networks. Being a decentralized graph of relationships, basically a Web of Trust, Trust Graph is distributed among all network peers. 
+- [Trust Graph](#trust-graph)
+  - [Overview](#overview)
+  - [Why is it important?](#why-is-it-important)
+  - [What is it?](#what-is-it)
+  - [How to Use it in Aqua](#how-to-use-it-in-aqua)
+    - [How to import](#how-to-import)
+    - [How to add roots](#how-to-add-roots)
+    - [How to issue and add trust](#how-to-issue-and-add-trust)
+    - [How to revoke the trust](#how-to-revoke-the-trust)
+    - [How to get certificates](#how-to-get-certificates)
+    - [How to get weights](#how-to-get-weights)
+  - [How to use it in TS/JS](#how-to-use-it-in-tsjs)
+  - [Use cases](#use-cases)
+    - [Create a trusted subnetwork](#create-a-trusted-subnetwork)
+    - [Service permission management](#service-permission-management)
+    - [Label trusted peers and execute computation only on this peers](#label-trusted-peers-and-execute-computation-only-on-this-peers)
+  - [FAQ](#faq)
+  - [API](#api)
+  - [Directory structure](#directory-structure)
+  - [Learn Aqua](#learn-aqua)
 
-Specifically, Trust Graph is used to prioritize connections from known peers to counteract Sybil attacks while still keeping network open by reserving resources for unknown peers. 
+## Overview
+The problem of access control and permissions is solved with centralized CAs (Certificate Authority) in web 2.0. However, such problem is urgent and becomes even more challenging considering a decentralized nature of web 3.0. TrustGraph is our point of view on the solution for this challenge.
 
-At the same time, Trust Graph can be used at the application level in various ways such as prioritization of service execution on authorized peers or to define an interconnected subnetwork among peers of a single protocol.
+TrustGraph is a bottom layer of trust for open p2p networks: every peer may be provided with SSL-like certificates that promoted over the network. Service providers and peers can treat certificate holders differently based on their certificate set.
 
-## How to Use it in TypeScript
+TrustGraph is a basic component that allows storing and managing certificates without additional logic about how to decide whom to trust and whom to treat as unreliable.
+
+## Why is it important?
+
+The problem of peer choice and prioritization is very urgent in p2p networks. We can't use the network reliably and predictably without trust to any network participant. We also should mark and avoid malicious peers. In addition we need to control our application access and permissions in runtime, so it performs continuously without interruptions and redeployments.
+
+## What is it?
+
+TrustGraph is basically a directed graph with one root at least, vertices are peer ids, and edges are one of the two types of cryptographic relations: trust and revocation.
+
+**Root** is a peer id that we unconditionally trust until it is removed, and is defined by the node owner. Every root has characteristics that represent the maximum length for a chain of trusts.
+
+As a **path to the root**, we consider a path with only trust edges, given the following rule: chain `R -> A -> ...-> C` is not a path if A revoked C.
+
+**Trust** is a cryptographic relation representing that peer A trusts peer B until this trust expires or is revoked. Trust relation is transitive. If peer A trusts peer B, and peer B trusts peer C, it results in peer A trusts peer C transitively. Trust relation means that you trust to connect, compute or store based on your business logic and chosen metrics. For example, if you want to perform some computation and some well-known peers do that, and are trusted by others you trust, so you can safely use them for computing but not to store sensitive information (personal keys, etc).
+
+Trust data structure contains the following fields:
+- peer id, trust is issued to
+- creation timestamp
+- expiration timestamp
+- a signature of the issuer that contains all of the previous fields signed
+
+So the trust is signed and tamperproof by design.
+
+**Certificate** is a chain of trusts started with a self-signed root trust. Considering Trust and Certificate data structures, it is possible to track the chain of trust relations: the `issued_for` field of the first trust in a chain indicates a root peer id, second — whom root trusts, etc. So if we have a chain `R->A->B->C` in the certificate it looks like a chain of the following trusts: `R->R`, `R->A`, `A->B`, `B->C`. A certificate is tamperproof since it is a composition of signed trusts.
+
+![image](images/diagram.png)
+
+So peerA is trusted by peerB if there is a path between them in the instance of TrustGraph. The selection of certificates is subjective and defined by a node owner by choice of roots and maximum chain lengths. For now, there are no default metrics for a general case.
+
+**Revocation** is a cryptographic relation representing that a peer A considers a peer C malicious or unreliable. For example, all chains containing paths from A to C will not be treated as valid. So if A trusts a peer B, and B trusts C, a peer A has no trust to C transitively, it would have otherwise.
+
+![image](images/revocation.png)
+
+Every peer has a **weight**. A weight signifies a power of 2 or zero. If there is no path from any root to a peer, given revocations, its weight equals zero. The closer to the root, the bigger the weight. Weights are also subjective and relevant in the scope of a local TrustGraph.
+
+![image](images/weights.png)
+
+TrustGraph is a builtin meaning that every node is bundled with a TrustGraph instance and predefined certificates.
+
+Trust is transitive in terms of cryptographic relations. On the other hand, a subset of trusts and certificates is subjective for each network participant because of the choice of roots.
+
+
+## How to Use it in Aqua
+### How to import
+```
+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
+```
+
+### How to add roots
+- `set_root(peer_id: PeerId, max_chain_len: u32) -> SetRootResult`
+- `add_root_trust(node: PeerId, peer_id: PeerId, max_chain_len: u32) -> ?Error`
+
+Let's set our peer id as a root on our relay and add self-signed trust:
+```rust
+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()
+```
+- also you can use `set_root` + `add_trust` to achieve the same goal
+- [how to add keypair to Sig service](https://doc.fluence.dev/docs/fluence-js/3_in_depth#signing-service)
+- roots can be added only by the service owner
+- `max_chain_len` specifies a number of trusts in a chain for the root. Zero for chains that contain only root trust.
+
+### How to issue and add trust
+
+- `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`
+
+Let's issue trust, and import it to our relay:
+```rust
+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` is a combination of `issue_trust` and `import_trust`
+- if you want to issue trust not by `INIT_PEER_ID` check the Sig service [docs](https://doc.fluence.dev/docs/fluence-js/3_in_depth#signing-service)
+
+### How to revoke the trust
+
+- `issue_revocation(revoked_by: PeerId, revoked: PeerId) -> ?Revocation, ?Error`
+- `import_revocation(revocation: Revocation) -> ?Error`
+- `revoke(node: PeerId, revoked_by: PeerId, revoked: PeerId) -> ?Error`
+
+Let's revoke some peers by our peer id:
+```rust
+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` is a combination of `issue_revocation` and `import_revocation`
+- if you want to issue revocation not by `INIT_PEER_ID` check the Sig service [docs](https://doc.fluence.dev/docs/fluence-js/3_in_depth#signing-service)
+
+
+### How to get certificates
+
+- `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`
+
+Let's get all certificates issued by us to our relay peer id (HOST_PEER_ID):
+```rust
+func get_certs_issued_by_me() -> AllCertsResult:
+  on HOST_PEER_ID:
+     result <- get_host_certs_from(INIT_PEER_ID)
+  <- result
+```
+- `get_host_certs` is just an alias for `get_all_certs(HOST_PEER_ID)`
+- `_from` calls results contain only certificates with trust issued by `issuer`
+
+### How to get weights
+- `get_weight(peer_id: PeerId) -> WeightResult`
+- `get_weight_from(peer_id: PeerId, issuer: PeerId) -> WeightResult`
+
+Let's get our weight for certificates which contain trust by our relay
+```rust
+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` returns result among all the certificates, on the other hand, `get_weight_from` return certificates containing trust by the issuer only
+
+## How to use it in TS/JS
+1. Add `export.aqua` as in the Aqua [documentation](https://doc.fluence.dev/aqua-book/libraries#in-typescript-and-javascript)
+2. Add the following to your dependencies
+   - `@fluencelabs/trust-graph`
+   - `@fluencelabs/aqua`
+   - `@fluencelabs/aqua-lib`
+   - `@fluencelabs/fluence`
+   - `@fluencelabs/fluence-network-environment`
+
+3. Import dependencies
+  ```typescript
+  import * as tg from "./generated/export";
+  import { Fluence, KeyPair } from "@fluencelabs/fluence";
+  import { krasnodar, Node } from "@fluencelabs/fluence-network-environment";
+  ```
+4. Create a client (specify keypair if you are node owner
+[link](https://github.com/fluencelabs/node-distro/blob/main/fluence/Config.default.toml#L9))
+
+  ```typescript
+  await Fluence.start({ connectTo: relay /*, KeyPair: builtins_keypair*/});
+  ```
+5. Add a root and issue root trust.
+  ```typescript
+  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. By default, trusts/revocations signed with the client's private key. To sign with different keys see the Sig service [documentation](https://doc.fluence.dev/docs/fluence-js/3_in_depth#signing-service).
+  ```typescript
+  // 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);
+  }
+  ```
+
+## Use cases
+
+### Create a trusted subnetwork
+
+You can organize a subnetwork with peers trusted by your choice or chosen metrics. So you can treat trusts given by a peer (or a key) as evidence.
+
+Let's consider we have peers A, B and C:
+- Choose a peer A as an authority, set it as a root for the local TrustGraphs on all peers
+- Issue and put self-signed by a peer A trust as a root trust
+- Issue trusts by a peer A a to peer B and a peer C, and put them on all peers
+- So for a call `get_weight_from(targetPeer, peerA)` will reflect whether targetPeer is in a subnetwork ABC
+
+### Service permission management
+
+You can specify in runtime who can access service functionality based on the local TrustGraph (certificates, weights). It's possible to check where the proof comes from based on [tetraplets](https://doc.fluence.dev/docs/knowledge_security). For example, only peers that have  a non-zero weight can execute a service function `trusted_call(weight: WeightResult) -> u8`.
+
+So if you want to have service permission management you should follow the steps:
+- Pass `WeightResult` from TrustGraph to the function that you need to control:
+ ```rust
+ ...
+ weight_result <- get_weight(INIT_PEER_ID)
+ result <- MyService.trusted_call(weight_result)
+ ...
+ ```
+- Inside your service you need to check tetraplets like [this](https://github.com/fluencelabs/registry/blob/main/service/src/misc.rs#L37) to be sure that they are resulted from the local TrustGraph
+- Add `INIT_PEER_ID` or another choosen key as a root
+- Issue trust to peers that can call this function:
+```rust
+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
+```
+
+### Label trusted peers and execute computation only on this peers
 
 See [example](./example):
-- How to call [`trust-graph`](./example/index.ts) functions in TS/JS 
+- How to call [`trust-graph`](./example/index.ts) functions in TS/JS
 - Step-by-step description [`README`](./example/README.md)
 
+
+## FAQ
+
+- Can a weight change during time?
+  - If the shortest path to a root changes, in case of trust expiration, importing or revocation, a weight also changes.
+
+- What does a zero weight mean?
+  - A zero weight means there is no trust and path from any roots to the target peer.
+
+- How we can interpret a certificate and/or a peer weight?
+  - A certificate contains a path from the root to the target peer we are looking for. A weight represents the presence of these certificates and peers' closeness to the root.
+
+- How are weights calculated and based on what feedback?
+  - Weights are calculated based on the existence of a chain of trusts from the roots. For example, if we have a root with a maximum chain length equal 4 and have a chain `R -> A -> B -> C`, so the corresponding weights of peers are `8`, `4`, `2`, `1`. Weights are the same if there are no changes in the paths.
+  As long as we have no metrics, all trust/revocation logic is a TrustGraph user's responsibility.
+
+- How do I set all weights to untrusted and then increase trust in a peer over time?
+  - All peers are untrusted by default. Trust is unmeasured, weight represents how far the peer is from the root, the bigger weight, the closer to the root, so if you want to increase the weight of the target peer, you should obtain the trust from the root or peers who are closer to the root than this peer.
+
+- How do I know that other peers are using the same processes to update weights?
+  - Weights calculated **locally** based on certificates that contain immutable signed trusts. Weights are subjective and have meaning only locally to this exact peer.
+
+-  Can I start my own instance of a trust graph or is there only a global version available?
+   - Every Fluence node is bundled with a builtin TrustGraph instance, but you can change or remove any service you want if you're a node owner.
+
 ## API
 
-High-level API is defined in the [trust-graph-api.aqua](./aqua/trust-graph-api.aqua) module.
+High-level API is defined in the [trust-graph-api.aqua](./aqua/trust-graph-api.aqua) module. API Reference soon will be available in the documentation.
 
 ## Directory structure
 
@@ -22,7 +305,7 @@ High-level API is defined in the [trust-graph-api.aqua](./aqua/trust-graph-api.a
 
 - [`keypair`](./keypair) directory is an abstracted cryptographical layer (key pairs, public keys, signatures, etc.)
 
-- [`service`](./service) is a package that provides `marine` API and could be compiled to a Wasm file. It is uses `SQLite` as storage
+- [`service`](./service) is a package that provides `marine` API and could be compiled to a Wasm file. It uses` SQLite` as storage
 
 - [`example`](./example) is a `js` script that shows how to use Trust Graph to label peers
 
@@ -35,58 +318,3 @@ High-level API is defined in the [trust-graph-api.aqua](./aqua/trust-graph-api.a
 * [Aqua Book](https://fluence.dev/aqua-book/)
 * [Aqua Playground](https://github.com/fluencelabs/aqua-playground)
 * [Aqua repo](https://github.com/fluencelabs/aqua)
-
-## How to use in 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
-```
-
-## How to use is js
-1. Add the following to your dependencies
-    - `@fluencelabs/trust-graph`
-    - `@fluencelabs/aqua`
-    - `@fluencelabs/aqua-lib`
-    - `@fluencelabs/fluence`
-    - `@fluencelabs/fluence-network-environment`
-
-2. Import dependencies
-   ```typescript
-   import * as tg from "./generated/export";
-   import { Fluence, KeyPair } from "@fluencelabs/fluence";
-   import { krasnodar, Node } from "@fluencelabs/fluence-network-environment";
-   ```
-3. Create client (specify keypair if you are node owner
-[link](https://github.com/fluencelabs/node-distro/blob/main/fluence/Config.default.toml#L9))
-
-   ```typescript
-   await Fluence.start({ connectTo: relay /*, KeyPair: builtins_keypair*/});
-   ```
-4. Add root and issue root trust.
-   ```typescript
-   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 = tg.timestamp_sec() + 9999999999;
-   let error = await tg.add_root_trust(relay, peer_id, max_chain_len, far_future);
-   if (error !== null) {
-    console.log(error);
-   }
-   ```
-5. For now, trusts/revocations can only be signed with the client's private key.
-   Keypair specification will be available soon.
-   ```typescript
-   // 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);
-   }
-   ```

admin/index.ts

@@ -60,7 +60,7 @@ async function main(environment: Node[]) {
     console.log("Issuer private key: %s", issuer_sk_b58);
 
     let cur_time = await timestamp_sec(node);
-    let expires_at = cur_time + 60 * 60 * 24 * 365;
+    let expires_at = cur_time + 60 * 60 * 24 * 365 * 2;
     let certificates = [];
     // self-signed root trust
     let root_trust = await issue_trust_helper(node, root_kp,  root_kp.Libp2pPeerId.toB58String(), root_kp.Libp2pPeerId.toB58String(), expires_at, cur_time);

admin/package.json

@@ -13,10 +13,10 @@
   "author": "Fluence Labs",
   "license": "MIT",
   "dependencies": {
-    "@fluencelabs/aqua": "^0.5.2-257",
-    "@fluencelabs/aqua-lib": "^0.3.4",
-    "@fluencelabs/fluence": "^0.18.0",
-    "@fluencelabs/fluence-network-environment": "^1.0.10",
+    "@fluencelabs/aqua": "^0.9.1-374",
+    "@fluencelabs/aqua-lib": "^0.6.0",
+    "@fluencelabs/fluence": "^0.27.5",
+    "@fluencelabs/fluence-network-environment": "^1.0.13",
     "@fluencelabs/trust-graph": "file:../aqua",
     "bs58": "^4.0.1"
   },

aqua/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## [0.4.4](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.3...trust-graph-api-v0.4.4) (2023-05-09)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.3](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.1...trust-graph-api-v0.4.3) (2023-05-08)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.1](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.0...trust-graph-api-v0.4.1) (2023-04-13)
+
+
+### Bug Fixes
+
+* **deps:** update aqua to 0.10.3 ([fe902ac](https://github.com/fluencelabs/trust-graph/commit/fe902acc50a6b4c6bf97c487f3e47ae0f5ef8a95))
+* **deps:** update aqua-lib to 0.7.0 ([fe902ac](https://github.com/fluencelabs/trust-graph/commit/fe902acc50a6b4c6bf97c487f3e47ae0f5ef8a95))
+
+## [0.4.0](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.3.2...trust-graph-api-v0.4.0) (2023-03-15)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions

aqua/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@fluencelabs/trust-graph",
-  "version": "0.2.2",
+  "version": "0.4.4",
   "description": "Aqua Trust Graph API library",
   "files": [
     "*.aqua"
   ],
   "dependencies": {
-    "@fluencelabs/aqua-lib": "^0.5.2"
+    "@fluencelabs/aqua-lib": "^0.7.0"
   },
   "scripts": {
     "generate-aqua": "../service/build.sh",
@@ -31,6 +31,6 @@
   },
   "homepage": "https://github.com/fluencelabs/trust-graph#readme",
   "devDependencies": {
-    "@fluencelabs/aqua": "^0.7.4-322"
+    "@fluencelabs/aqua": "^0.10.3"
   }
 }

builtin-package/blueprint.json

@@ -1,7 +0,0 @@
-{
-  "name": "trust-graph",
-  "dependencies": [
-    "name:sqlite3",
-    "name:trust-graph"
-  ]
-}

builtin-package/package.sh

@@ -3,20 +3,39 @@ set -o pipefail -o nounset -o errexit
 
 # set current working directory to script directory to run script from everywhere
 cd "$(dirname "$0")"
-SCRIPT_DIR="$(pwd)"
+PACKAGE_DIR="$(pwd)/../package/trust-graph"
+
+(
+    rm -rf $PACKAGE_DIR/*
+    mkdir -p $PACKAGE_DIR
+)
 
 (
     echo "*** copy wasm files ***"
     cd ../service
-    cp artifacts/*.wasm "$SCRIPT_DIR"
+    cp artifacts/*.wasm "$PACKAGE_DIR"
 )
 
+(
+    echo "*** copy on_start script ***"
+    cp on_start.json "$PACKAGE_DIR"
+    cp on_start.air "$PACKAGE_DIR"
+)
+
+TRUST_GRAPH_CID=$(ipfs add -q --only-hash --cid-version=1 --chunker=size-262144 $PACKAGE_DIR/trust-graph.wasm)
+SQLITE_CID=$(ipfs add -q --only-hash --cid-version=1 --chunker=size-262144 $PACKAGE_DIR/sqlite3.wasm)
+mv $PACKAGE_DIR/trust-graph.wasm "$PACKAGE_DIR"/"$TRUST_GRAPH_CID".wasm
+mv $PACKAGE_DIR/sqlite3.wasm "$PACKAGE_DIR"/"$SQLITE_CID".wasm
+cp trust-graph_config.json "$PACKAGE_DIR"/"$TRUST_GRAPH_CID"_config.json
+cp sqlite3_config.json "$PACKAGE_DIR"/"$SQLITE_CID"_config.json
+
+# write blueprint.json
+echo "{}" | jq --arg trust_graph_cid "$TRUST_GRAPH_CID" --arg sqlite_cid "$SQLITE_CID" '{"name": "trust-graph", "dependencies":[{"/":$sqlite_cid},{"/":$trust_graph_cid}]}' > "$PACKAGE_DIR/blueprint.json"
+
 (
     echo "*** create builtin distribution package ***"
-    cd ..
-    mv builtin-package trust-graph
-    tar --exclude="package.sh" -f trust-graph.tar.gz -zcv ./trust-graph
-    mv trust-graph builtin-package
+    cd $PACKAGE_DIR/..
+    tar -f trust-graph.tar.gz -zcv ./trust-graph
 )
 
 echo "*** done ***"

example/README.md

@@ -1,10 +1,49 @@
 ## Description
-This example shows how to use Trust Graph to label peers. There are some `trusted_computation` which can only be executed 
-on labeled peer. The label is determined by the presence of certificate from `%init_peer_id` to this peer.
+This example shows how to use Trust Graph for code execution only on trusted peers. There are some `trusted_computation` which can only be performed on a trusted peer. The label is determined by the presence of the certificate from `INIT_PEER_ID` to this peer. We use peer id from [`example_secret_key.ed25519`](../example_secret_key.ed25519) as `INIT_PEER_ID` since every node bundled with the certificate issued to this key, it should be used only for test purposes.
+
+## Run example on network
+
+1. Run `npm i`
+2. Run `npm run start`
+
+
+## Run example on network
+1. Run `npm i`
+2. Run `npm run start`
 
 ## Run example locally
+
 1. Go to `local-network`
 2. Run `docker compose up -d` to start Fluence node
-3. Go back to `../example`
-4. Run `npm i`
-5. Run `npm run start`
+3. It takes some time depending on your machine for node to start and builtin services deployed. Wait for this log line: `[2022-07-06T11:33:50.782054Z INFO  particle_node] Fluence has been successfully started.`
+4. Go back to `../example`
+5. Run `npm i`
+6. Run `npm run start local`
+
+## Expected output
+
+After successful execution you will get this result:
+```
+In this example we try to execute some trusted computations based on trusts
+📘 Will connect to testNet
+📗 created a fluence peer 12D3KooWD2vAZva1u3TQgoxebBUBsaGMNawKjVkp57M6UcwNwXNv with relay 12D3KooWEXNUbCXooUwHrHBbrmjsrpHXoEphPwbjQXEGyzbqKnE9
+
+📕 Trusted computation on node 12D3KooWEXNUbCXooUwHrHBbrmjsrpHXoEphPwbjQXEGyzbqKnE9 failed, error: there is no certs for this peer
+📕 Trusted computation on node 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz failed, error: there is no certs for this peer
+📕 Trusted computation on node 12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er failed, error: there is no certs for this peer
+
+🌀 Issue trust to nodeB 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz and nodeC: 12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er
+Trust issued for 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz successfully added
+Trust issued for 12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er successfully added
+
+📕 Trusted computation on node 12D3KooWEXNUbCXooUwHrHBbrmjsrpHXoEphPwbjQXEGyzbqKnE9 failed, error: there is no certs for this peer
+📗 Trusted computation on node 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz successful, result is 5
+📗 Trusted computation on node 12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er successful, result is 5
+
+🚫 Revoke trust to nodeB
+Trust issued for 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz revoked
+
+📕 Trusted computation on node 12D3KooWEXNUbCXooUwHrHBbrmjsrpHXoEphPwbjQXEGyzbqKnE9 failed, error: there is no certs for this peer
+📕 Trusted computation on node 12D3KooWMhVpgfQxBLkQkJed8VFNvgN4iE6MD7xCybb1ZYWW2Gtz failed, error: there is no certs for this peer
+📗 Trusted computation on node 12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er successful, result is 5
+```

example/index.ts

@@ -39,22 +39,14 @@ let local: Node[] = [
     },
 ];
 
-async function revoke_all(relay: string, revoked_by: string) {
-    for (var node of local) {
+async function revoke_all(relay: string, revoked_by: string, nodes: Node[]) {
+    for (var node of nodes) {
         let error = await tg.revoke(relay, revoked_by, node.peerId);
         if (error !== null) {
             console.log(error)
         }
     }
 }
-async function add_root(relay: string, peer_id: string) {
-    let current_time = await tg.timestamp_sec();
-    let far_future = current_time + 9999999;
-    let error = await tg.add_root_trust(relay, peer_id, 2, far_future);
-    if (error !== null) {
-        console.log(error)
-    }
-}
 
 async function add_new_trust_checked(relay: string, issuer: string, issued_for_peer_id: string, expires_at_sec: number) {
     let error = await tg.add_trust(relay, issuer, issued_for_peer_id, expires_at_sec);
@@ -84,14 +76,13 @@ async function exec_trusted_computation(node: string) {
     }
 }
 
-async function main() {
-    console.log("In this example we try to execute some trusted computations based on trusts");
-    console.log("📘 Will connect to local nodes");
-    // key from local-network/builtins_secret_key.ed25519 to connect as builtins owner
-    let sk = bs58.decode("5FwE32bDcphFzuMca7Y2qW1gdR64fTBYoRNvD4MLE1hecDGhCMQGKn8aseMr5wRo4Xo2CRFdrEAawUNLYkgQD78K").slice(0, 32); // first 32 bytes - secret key, second - public key
+async function main(nodes: Node[]) {
+    // example_secret_key.ed25519
+    let sk = bs58.decode("E5ay3731i4HN8XjJozouV92RDMGAn3qSnb9dKSnujiWv");
+
     let builtins_keypair = await KeyPair.fromEd25519SK(sk);
 
-    let relay = local[0];
+    let relay = nodes[0];
     await Fluence.start({ connectTo: relay, KeyPair: builtins_keypair });
     console.log(
         "📗 created a fluence peer %s with relay %s",
@@ -105,41 +96,55 @@ async function main() {
     let far_future = current_time + 9999999;
 
     // clear all trusts from our peer id on relay
-    await revoke_all(relay.peerId, local_peer_id);
+    await revoke_all(relay.peerId, local_peer_id, nodes.slice(0, 3));
+
     // wait to be sure that last revocation will be older than future trusts at least on 1 second (because timestamp in secs)
     await new Promise(f => setTimeout(f, 1000));
 
-    // set our peer id as root to our relay
-    await add_root(relay.peerId, local_peer_id);
-
-    let nodeA = local[0].peerId
-    let nodeB = local[1].peerId
-    let nodeC = local[2].peerId
+    let nodeA = nodes[0].peerId
+    let nodeB = nodes[1].peerId
+    let nodeC = nodes[2].peerId
 
+    console.log();
     // try to exec computation on every node, will fail
     await exec_trusted_computation(nodeA); // fail
     await exec_trusted_computation(nodeB); // fail
     await exec_trusted_computation(nodeC); // fail
 
-    console.log("🌀 Issue trust to nodeB: %s", nodeB);
+    console.log();
+    console.log("🌀 Issue trust to nodeB %s and nodeC: %s", nodeB, nodeC);
     await add_new_trust_checked(relay.peerId, local_peer_id, nodeB, far_future);
+    await add_new_trust_checked(relay.peerId, local_peer_id, nodeC, far_future);
 
+    console.log();
     await exec_trusted_computation(nodeA); // fail
     await exec_trusted_computation(nodeB); // success
-    await exec_trusted_computation(nodeC); // fail
+    await exec_trusted_computation(nodeC); // success
+    console.log();
 
     await new Promise(f => setTimeout(f, 1000));
     console.log("🚫 Revoke trust to nodeB");
     await revoke_checked(relay.peerId, local_peer_id, nodeB);
 
+    console.log();
     await exec_trusted_computation(nodeA); // fail
     await exec_trusted_computation(nodeB); // fail
-    await exec_trusted_computation(nodeC); // fail
+    await exec_trusted_computation(nodeC); // success
     return;
 }
 
+console.log("In this example we try to execute some trusted computations based on trusts");
+let args = process.argv.slice(2);
+var environment: Node[];
+if (args.length >= 1 && args[0] == "local") {
+  environment = local;
+  console.log("📘 Will connect to local nodes");
+} else {
+  environment = testNet;
+  console.log("📘 Will connect to testNet");
+}
 
-main()
+main(environment)
     .then(() => process.exit(0))
     .catch((error) => {
         console.error(error);

example_secret_key.ed25519

@@ -1 +1 @@
-E5ay3731i4HN8XjJozouV92RDMGAn3qSnb9dKSnujiWv
+E5ay3731i4HN8XjJozouV92RDMGAn3qSnb9dKSnujiWv

keypair/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.10.1](https://github.com/fluencelabs/trust-graph/compare/keypair-v0.10.0...keypair-v0.10.1) (2023-05-02)
+
+
+### Features
+
+* **keypair:** Make `KeyFormat` more convenient ([#91](https://github.com/fluencelabs/trust-graph/issues/91)) ([9b942ea](https://github.com/fluencelabs/trust-graph/commit/9b942eacca49d0468b4d7512667102363a6c9aa3))
+
+## [0.10.0](https://github.com/fluencelabs/trust-graph/compare/keypair-v0.9.0...keypair-v0.10.0) (2023-03-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77))
+
+### Features
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77)) ([080503d](https://github.com/fluencelabs/trust-graph/commit/080503dcfa2ecf8d09167ff9fe7f750fadf49035))
+* **keypair:** add KeyPair::from_secret_key ([#50](https://github.com/fluencelabs/trust-graph/issues/50)) ([a6ce8d9](https://github.com/fluencelabs/trust-graph/commit/a6ce8d9eee20e1ea24eb27c38ac6df6d878292ae))
+
+## [Unreleased]
+
+## [0.8.1] - 2022-10-06
+
+### Added
+- *(keypair)* add KeyPair::from_secret_key (#50)
+
+### Other
+- set version of fluence-keypair to 0.8.0
+- fluence-keypair 0.8.0
+- libp2p-core 0.33.0 (#49)
+- remove circle, update gh, add lints; remove warnings (#43)
+- fluence-keypair 0.6.0
+- libp2p-core 0.31.0 (from crates.io) (#37)
+- Remove serde version lock (#15)
+- Fix revocations logic (#34)
+- Trust Graph: implement WASM built-in (#18)
+- Move fluence-identity to fluence-keypair (#17)

keypair/Cargo.toml

@@ -1,33 +1,30 @@
 [package]
 name = "fluence-keypair"
-version = "0.6.0"
+version = "0.10.1"
 authors = ["Fluence Labs"]
-edition = "2018"
+edition = "2021"
 description = "identity"
 license = "Apache-2.0"
 repository = "https://github.com/fluencelabs/trust-graph"
 
 [dependencies]
 serde = { version = "1.0.118", features = ["derive"] }
-serde_json = "1.0.58"
-bs58 = "0.3.1"
+bs58 = "0.4.0"
 ed25519-dalek = { version = "1.0.1", features = ["serde", "std"] }
-rand = "0.7.0"
-signature = "1.3.0"
-ed25519 = "1.0.3"
-serde_with = "1.6.0"
+rand = "0.8.5"
 thiserror = "1.0.23"
 lazy_static = "1.2"
-libsecp256k1 = "0.3.1"
+libsecp256k1 = "0.7.1"
 asn1_der = "0.6.1"
-sha2 = "0.9.1"
+sha2 = "0.10.6"
 zeroize = "1"
 serde_bytes = "0.11"
-libp2p-core = { version = "0.31", default-features = false, features = [ "secp256k1" ] }
 eyre = "0.6.5"
+libp2p-identity = { workspace = true, default-features = false, features = ["peerid", "rsa", "ed25519", "secp256k1", "multihash"] }
+multihash = { version = "0.18.0", features = ["identity"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 ring = { version = "0.16.9", features = ["alloc", "std"], default-features = false }
 
 [dev-dependencies]
-quickcheck = "0.9.0"
+quickcheck = "1.0.3"

keypair/rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2022-01-16"
-targets = [ "x86_64-apple-darwin", "x86_64-unknown-linux-gnu" ]
+channel = "nightly-2022-08-30"
+targets = [ "x86_64-apple-darwin", "x86_64-unknown-linux-gnu" ]

keypair/src/error.rs

@@ -68,7 +68,7 @@ pub enum SigningError {
     Secp256k1(
         #[from]
         #[source]
-        secp256k1::Error,
+        libsecp256k1::Error,
     ),
 }
 
@@ -83,5 +83,5 @@ pub enum VerificationError {
     Rsa(#[source] ring::error::Unspecified, String, String),
 
     #[error("Failed to verify signature {1} with {2} secp256k1 public key: {0}")]
-    Secp256k1(#[source] secp256k1::Error, String, String),
+    Secp256k1(#[source] libsecp256k1::Error, String, String),
 }

keypair/src/key_pair.rs

@@ -26,7 +26,7 @@ use crate::public_key::PublicKey;
 use crate::rsa;
 use crate::secp256k1;
 use crate::signature::Signature;
-use libp2p_core::PeerId;
+use libp2p_identity::PeerId;
 use std::convert::TryFrom;
 use std::str::FromStr;
 
@@ -48,6 +48,7 @@ use std::str::FromStr;
 /// ```
 ///
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyFormat {
     Ed25519,
     #[cfg(not(target_arch = "wasm32"))]
@@ -168,6 +169,18 @@ impl KeyPair {
         }
     }
 
+    /// Get the key format of this keypair.
+    pub fn key_format(&self) -> KeyFormat {
+        use KeyPair::*;
+
+        match self {
+            Ed25519(_) => KeyFormat::Ed25519,
+            #[cfg(not(target_arch = "wasm32"))]
+            Rsa(_) => KeyFormat::Rsa,
+            Secp256k1(_) => KeyFormat::Secp256k1,
+        }
+    }
+
     /// Get the public key of this keypair.
     pub fn public(&self) -> PublicKey {
         use KeyPair::*;
@@ -219,21 +232,33 @@ impl KeyPair {
         }
     }
 
+    pub fn from_secret_key(bytes: Vec<u8>, format: KeyFormat) -> Result<Self, DecodingError> {
+        use KeyPair::*;
+
+        match format {
+            KeyFormat::Ed25519 => Ok(Ed25519(ed25519::SecretKey::from_bytes(bytes)?.into())),
+            KeyFormat::Secp256k1 => Ok(Secp256k1(secp256k1::SecretKey::from_bytes(bytes)?.into())),
+            #[cfg(not(target_arch = "wasm32"))]
+            KeyFormat::Rsa => Err(DecodingError::KeypairDecodingIsNotSupported),
+        }
+    }
+
     pub fn get_peer_id(&self) -> PeerId {
         self.public().to_peer_id()
     }
 }
 
-impl From<libp2p_core::identity::Keypair> for KeyPair {
-    fn from(key: libp2p_core::identity::Keypair) -> Self {
-        use libp2p_core::identity::Keypair::*;
+impl From<libp2p_identity::Keypair> for KeyPair {
+    fn from(key: libp2p_identity::Keypair) -> Self {
+        use libp2p_identity::Keypair::*;
 
+        #[allow(deprecated)] //TODO: fix it later
         match key {
             Ed25519(kp) => KeyPair::Ed25519(ed25519::Keypair::decode(&mut kp.encode()).unwrap()),
             #[cfg(not(target_arch = "wasm32"))]
             // safety: these Keypair structures are identical
             Rsa(kp) => KeyPair::Rsa(unsafe {
-                std::mem::transmute::<libp2p_core::identity::rsa::Keypair, rsa::Keypair>(kp)
+                std::mem::transmute::<libp2p_identity::rsa::Keypair, rsa::Keypair>(kp)
             }),
             Secp256k1(kp) => KeyPair::Secp256k1(secp256k1::Keypair::from(
                 secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
@@ -242,23 +267,24 @@ impl From<libp2p_core::identity::Keypair> for KeyPair {
     }
 }
 
-impl From<KeyPair> for libp2p_core::identity::Keypair {
+impl From<KeyPair> for libp2p_identity::Keypair {
     fn from(key: KeyPair) -> Self {
-        use libp2p_core::identity;
-        use libp2p_core::identity::Keypair;
+        use libp2p_identity::Keypair;
         use KeyPair::*;
 
+        #[allow(deprecated)] //TODO: fix it later
         match key {
             Ed25519(kp) => Keypair::Ed25519(
-                identity::ed25519::Keypair::decode(kp.encode().to_vec().as_mut_slice()).unwrap(),
+                libp2p_identity::ed25519::Keypair::decode(kp.encode().to_vec().as_mut_slice())
+                    .unwrap(),
             ),
             #[cfg(not(target_arch = "wasm32"))]
             // safety: these Keypair structures are identical
             Rsa(kp) => Keypair::Rsa(unsafe {
-                std::mem::transmute::<rsa::Keypair, libp2p_core::identity::rsa::Keypair>(kp)
+                std::mem::transmute::<rsa::Keypair, libp2p_identity::rsa::Keypair>(kp)
             }),
-            Secp256k1(kp) => Keypair::Secp256k1(identity::secp256k1::Keypair::from(
-                identity::secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
+            Secp256k1(kp) => Keypair::Secp256k1(libp2p_identity::secp256k1::Keypair::from(
+                libp2p_identity::secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
             )),
         }
     }

keypair/src/lib.rs

@@ -41,7 +41,7 @@ pub use key_pair::KeyFormat;
 pub use key_pair::KeyPair;
 
 pub mod peerid_serializer {
-    use libp2p_core::PeerId;
+    use libp2p_identity::PeerId;
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
     use std::str::FromStr;
 
@@ -58,7 +58,7 @@ pub mod peerid_serializer {
     {
         let str = String::deserialize(deserializer)?;
         PeerId::from_str(&str).map_err(|e| {
-            serde::de::Error::custom(format!("peer id deserialization failed for {:?}", e))
+            serde::de::Error::custom(format!("peer id deserialization failed for {e:?}"))
         })
     }
 }

keypair/src/public_key.rs

@@ -21,7 +21,7 @@ use crate::secp256k1;
 use crate::signature::Signature;
 
 use crate::key_pair::KeyFormat;
-use libp2p_core::PeerId;
+use libp2p_identity::PeerId;
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
@@ -124,10 +124,11 @@ impl PublicKey {
     }
 }
 
-impl From<libp2p_core::identity::PublicKey> for PublicKey {
-    fn from(key: libp2p_core::identity::PublicKey) -> Self {
-        use libp2p_core::identity::PublicKey::*;
+impl From<libp2p_identity::PublicKey> for PublicKey {
+    fn from(key: libp2p_identity::PublicKey) -> Self {
+        use libp2p_identity::PublicKey::*;
 
+        #[allow(deprecated)] //TODO: fix it later
         match key {
             Ed25519(key) => {
                 PublicKey::Ed25519(ed25519::PublicKey::decode(&key.encode()[..]).unwrap())
@@ -141,10 +142,9 @@ impl From<libp2p_core::identity::PublicKey> for PublicKey {
     }
 }
 
-impl From<PublicKey> for libp2p_core::identity::PublicKey {
+impl From<PublicKey> for libp2p_identity::PublicKey {
     fn from(key: PublicKey) -> Self {
-        use libp2p_core::identity as libp2p_identity;
-
+        #[allow(deprecated)] //TODO: fix it later
         match key {
             PublicKey::Ed25519(key) => libp2p_identity::PublicKey::Ed25519(
                 libp2p_identity::ed25519::PublicKey::decode(&key.encode()[..]).unwrap(),
@@ -160,10 +160,10 @@ impl From<PublicKey> for libp2p_core::identity::PublicKey {
     }
 }
 
-impl TryFrom<libp2p_core::PeerId> for PublicKey {
+impl TryFrom<PeerId> for PublicKey {
     type Error = DecodingError;
 
-    fn try_from(peer_id: libp2p_core::PeerId) -> Result<Self, Self::Error> {
+    fn try_from(peer_id: PeerId) -> Result<Self, Self::Error> {
         Ok(as_public_key(&peer_id)
             .ok_or_else(|| DecodingError::PublicKeyNotInlined(peer_id.to_base58()))?
             .into())
@@ -171,14 +171,12 @@ impl TryFrom<libp2p_core::PeerId> for PublicKey {
 }
 
 /// Convert PeerId to libp2p's PublicKey
-fn as_public_key(peer_id: &PeerId) -> Option<libp2p_core::PublicKey> {
-    use libp2p_core::multihash;
-
+fn as_public_key(peer_id: &PeerId) -> Option<libp2p_identity::PublicKey> {
     let mhash = peer_id.as_ref();
 
     match multihash::Code::try_from(mhash.code()) {
         Ok(multihash::Code::Identity) => {
-            libp2p_core::PublicKey::from_protobuf_encoding(mhash.digest()).ok()
+            libp2p_identity::PublicKey::from_protobuf_encoding(mhash.digest()).ok()
         }
         _ => None,
     }
@@ -209,8 +207,8 @@ mod tests {
     fn public_key_peer_id_conversions() {
         let kp = KeyPair::generate_secp256k1();
         let fluence_pk = kp.public();
-        let libp2p_pk: libp2p_core::PublicKey = fluence_pk.clone().into();
-        let peer_id = PeerId::from_public_key(libp2p_pk);
+        let libp2p_pk: libp2p_identity::PublicKey = fluence_pk.clone().into();
+        let peer_id = PeerId::from_public_key(&libp2p_pk);
         let fluence_pk_converted = PublicKey::try_from(peer_id).unwrap();
 
         assert_eq!(fluence_pk, fluence_pk_converted);

keypair/src/rsa.rs

@@ -127,7 +127,7 @@ impl fmt::Debug for PublicKey {
         let mut hex = String::with_capacity(bytes.len() * 2);
 
         for byte in bytes {
-            write!(hex, "{:02x}", byte).expect("Can't fail on writing to string");
+            write!(hex, "{byte:02x}").expect("Can't fail on writing to string");
         }
 
         f.debug_struct("PublicKey").field("pkcs1", &hex).finish()
@@ -234,7 +234,6 @@ pub struct Signature(pub Vec<u8>);
 mod tests {
     use super::*;
     use quickcheck::*;
-    use rand::seq::SliceRandom;
     use std::fmt;
 
     const KEY1: &'static [u8] = include_bytes!("test/rsa-2048.pk8");
@@ -251,8 +250,8 @@ mod tests {
     }
 
     impl Arbitrary for SomeKeypair {
-        fn arbitrary<G: Gen>(g: &mut G) -> SomeKeypair {
-            let mut key = [KEY1, KEY2, KEY3].choose(g).unwrap().to_vec();
+        fn arbitrary(g: &mut Gen) -> SomeKeypair {
+            let mut key = g.choose(&[KEY1, KEY2, KEY3]).unwrap().to_vec();
             SomeKeypair(Keypair::from_pkcs8(&mut key).unwrap())
         }
     }

keypair/src/secp256k1.rs

@@ -23,8 +23,8 @@ use crate::error::{DecodingError, SigningError, VerificationError};
 
 use asn1_der::{DerObject, FromDerObject};
 use core::fmt;
+use libsecp256k1::Message;
 use rand::RngCore;
-use secp256k1::Message;
 use serde::de::Error as SerdeError;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_bytes::{ByteBuf as SerdeByteBuf, Bytes as SerdeBytes};
@@ -66,7 +66,7 @@ impl fmt::Debug for Keypair {
 /// Promote a Secp256k1 secret key into a keypair.
 impl From<SecretKey> for Keypair {
     fn from(secret: SecretKey) -> Self {
-        let public = PublicKey(secp256k1::PublicKey::from_secret_key(&secret.0));
+        let public = PublicKey(libsecp256k1::PublicKey::from_secret_key(&secret.0));
         Keypair { secret, public }
     }
 }
@@ -80,7 +80,7 @@ impl From<Keypair> for SecretKey {
 
 /// A Secp256k1 secret key.
 #[derive(Clone)]
-pub struct SecretKey(secp256k1::SecretKey);
+pub struct SecretKey(libsecp256k1::SecretKey);
 
 impl fmt::Debug for SecretKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -92,12 +92,12 @@ impl SecretKey {
     /// Generate a new Secp256k1 secret key.
     pub fn generate() -> Self {
         let mut r = rand::thread_rng();
-        let mut b = [0; secp256k1::util::SECRET_KEY_SIZE];
+        let mut b = [0; libsecp256k1::util::SECRET_KEY_SIZE];
         // This is how it is done in `secp256k1::SecretKey::random` which
         // we do not use here because it uses `rand::Rng` from rand-0.4.
         loop {
             r.fill_bytes(&mut b);
-            if let Ok(k) = secp256k1::SecretKey::parse(&b) {
+            if let Ok(k) = libsecp256k1::SecretKey::parse(&b) {
                 return SecretKey(k);
             }
         }
@@ -108,8 +108,8 @@ impl SecretKey {
     /// error is returned.
     pub fn from_bytes(mut sk: impl AsMut<[u8]>) -> Result<Self, DecodingError> {
         let sk_bytes = sk.as_mut();
-        let secret =
-            secp256k1::SecretKey::parse_slice(&*sk_bytes).map_err(|_| DecodingError::Secp256k1)?;
+        let secret = libsecp256k1::SecretKey::parse_slice(&*sk_bytes)
+            .map_err(|_| DecodingError::Secp256k1)?;
         sk_bytes.zeroize();
         Ok(SecretKey(secret))
     }
@@ -122,7 +122,7 @@ impl SecretKey {
         // TODO: Stricter parsing.
         let der_obj = der.as_mut();
         let obj: Vec<DerObject> =
-            FromDerObject::deserialize((&*der_obj).iter()).map_err(|_| DecodingError::Secp256k1)?;
+            FromDerObject::deserialize((*der_obj).iter()).map_err(|_| DecodingError::Secp256k1)?;
         der_obj.zeroize();
         let sk_obj = obj.into_iter().nth(1).ok_or(DecodingError::Secp256k1)?;
         let mut sk_bytes: Vec<u8> =
@@ -149,7 +149,7 @@ impl SecretKey {
     /// ECDSA signature.
     pub fn sign_hashed(&self, msg: &[u8]) -> Result<Vec<u8>, SigningError> {
         let m = Message::parse_slice(msg).map_err(SigningError::Secp256k1)?;
-        Ok(secp256k1::sign(&m, &self.0)
+        Ok(libsecp256k1::sign(&m, &self.0)
             .0
             .serialize_der()
             .as_ref()
@@ -159,7 +159,7 @@ impl SecretKey {
 
 /// A Secp256k1 public key.
 #[derive(PartialEq, Eq, Clone, Debug)]
-pub struct PublicKey(secp256k1::PublicKey);
+pub struct PublicKey(libsecp256k1::PublicKey);
 
 impl PublicKey {
     /// Verify the Secp256k1 signature on a message using the public key.
@@ -171,7 +171,8 @@ impl PublicKey {
     pub fn verify_hashed(&self, msg: &[u8], sig: &[u8]) -> Result<(), VerificationError> {
         Message::parse_slice(msg)
             .and_then(|m| {
-                secp256k1::Signature::parse_der(sig).map(|s| secp256k1::verify(&m, &s, &self.0))
+                libsecp256k1::Signature::parse_der(sig)
+                    .map(|s| libsecp256k1::verify(&m, &s, &self.0))
             })
             .map_err(|e| {
                 VerificationError::Secp256k1(
@@ -197,7 +198,7 @@ impl PublicKey {
     /// Decode a public key from a byte slice in the the format produced
     /// by `encode`.
     pub fn decode(bytes: &[u8]) -> Result<Self, DecodingError> {
-        secp256k1::PublicKey::parse_slice(bytes, Some(secp256k1::PublicKeyFormat::Compressed))
+        libsecp256k1::PublicKey::parse_slice(bytes, Some(libsecp256k1::PublicKeyFormat::Compressed))
             .map_err(|_| DecodingError::Secp256k1)
             .map(PublicKey)
     }

rust-toolchain.toml

@@ -1,3 +1,4 @@
 [toolchain]
-channel = "nightly-2022-01-16"
-targets = [ "x86_64-apple-darwin", "x86_64-unknown-linux-gnu" ]
+channel = "nightly-2022-12-06"
+targets = [ "x86_64-apple-darwin", "wasm32-wasi", "wasm32-unknown-unknown", "x86_64-unknown-linux-gnu" ]
+components = [ "rustfmt", "clippy" ]

service/CHANGELOG.md

@@ -0,0 +1,97 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.1 to 0.4.2
+    * fluence-keypair bumped from 0.10.0 to 0.10.1
+
+## [0.4.4](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.3...trust-graph-wasm-v0.4.4) (2023-05-09)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-wasm:** Synchronize trust-graph, wasm and api versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.3 to 0.4.4
+
+## [0.4.3](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.2...trust-graph-wasm-v0.4.3) (2023-05-08)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-wasm:** Synchronize trust-graph, wasm and api versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.2 to 0.4.3
+
+## [0.4.1](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.0...trust-graph-wasm-v0.4.1) (2023-04-13)
+
+
+### Bug Fixes
+
+* **deps:** Add trust-graph to workspace and bump sqlite-wasm version ([#87](https://github.com/fluencelabs/trust-graph/issues/87)) ([da38a41](https://github.com/fluencelabs/trust-graph/commit/da38a41ba727a14774a71bba6612b1bf1f498db9))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.0 to 0.4.1
+
+## [0.4.0](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.3.2...trust-graph-wasm-v0.4.0) (2023-03-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77))
+
+### Features
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77)) ([080503d](https://github.com/fluencelabs/trust-graph/commit/080503dcfa2ecf8d09167ff9fe7f750fadf49035))
+* **keypair:** add KeyPair::from_secret_key ([#50](https://github.com/fluencelabs/trust-graph/issues/50)) ([a6ce8d9](https://github.com/fluencelabs/trust-graph/commit/a6ce8d9eee20e1ea24eb27c38ac6df6d878292ae))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.3.0 to 0.4.0
+    * fluence-keypair bumped from 0.9.0 to 0.10.0
+
+## [Unreleased]
+
+## [0.3.1] - 2022-10-06
+
+### Added
+- *(keypair)* add KeyPair::from_secret_key (#50)
+
+### Fixed
+- fix bug get_all_certs_from, update example (#44)
+- fix db paths (#28)
+
+### Other
+- set version of fluence-keypair to 0.8.0
+- fluence-keypair 0.8.0
+- libp2p-core 0.33.0 (#49)
+- remove circle, update gh, add lints; remove warnings (#43)
+- Add memory leak temporary mitigation (#42)
+- High-level Aqua API (#35)
+- fluence-keypair 0.6.0
+- libp2p-core 0.31.0 (from crates.io) (#37)
+- Fix revocations logic (#34)
+- Remove mutex from TG instance (#31)
+- refactoring (#30)
+- Trust Graph: implement WASM built-in (#18)

service/Cargo.toml

@@ -1,38 +1,36 @@
 [package]
 name = "trust-graph-wasm"
-version = "0.3.1"
+version = "0.4.4"
 authors = ["Fluence Labs"]
-edition = "2018"
+edition = "2021"
 description = "trust graph wasm"
 license = "Apache-2.0"
+publish = false
 
 [[bin]]
 name = "trust-graph"
 path = "src/main.rs"
 
 [dependencies]
-trust-graph = { version = "0.3.0", path = "../." }
-fluence-keypair = { version = "0.6.0", path = "../keypair" }
-marine-rs-sdk = { version = "0.6.14", features = ["logger"] }
-marine-sqlite-connector = "0.5.2"
+trust-graph = { version = "0.4.4", path = "../trust-graph" }
+fluence-keypair = { version = "0.10.1", path = "../keypair" }
+marine-rs-sdk = { version = "0.7.1", features = ["logger"] }
+marine-sqlite-connector = "0.8.0"
 
-libp2p-core = { version = "0.31", default-features = false, features = [ "secp256k1" ] }
+libp2p-identity = { workspace = true }
 
 log = "0.4.8"
 anyhow = "1.0.31"
-boolinator = "2.4.0"
 once_cell = "1.4.1"
-parking_lot = "0.11.1"
 serde_json = "1.0"
-bs58 = "0.3.1"
-rmp-serde = "0.15.0"
+bs58 = "0.4.0"
+rmp-serde = "1.1.1"
 bincode = "1.3.1"
-serde_bencode = "^0.2.3"
 thiserror = "1.0.23"
 
 [dev-dependencies]
-marine-rs-sdk-test = "0.4.0"
-rusqlite = "0.26.1"
+marine-rs-sdk-test = "0.9.1"
+rusqlite = "0.28.0"
 
 [build-dependencies]
-marine-rs-sdk-test = "0.4.0"
+marine-rs-sdk-test = "0.9.1"

service/Config.toml

@@ -5,12 +5,10 @@ modules_dir = "artifacts/"
     logger_enabled = true
 
     [module.wasi]
-        preopened_files = ["/tmp"]
-        mapped_dirs = { "tmp" = "/tmp" }
+        mapped_dirs = { "/tmp" = "data" }
 [[module]]
     name = "trust-graph"
     logger_enabled = true
 
     [module.wasi]
-        preopened_files = ["/tmp"]
-        mapped_dirs = { "tmp" = "/tmp" }
+        mapped_dirs = { "/tmp" = "data" }

service/build.sh

@@ -13,7 +13,7 @@ mkdir -p artifacts
 cp ../target/wasm32-wasi/release/trust-graph.wasm artifacts/
 
 # download SQLite 3 to use in tests
-curl -L https://github.com/fluencelabs/sqlite/releases/download/v0.15.0_w/sqlite3.wasm -o artifacts/sqlite3.wasm
+curl -sS -L https://github.com/fluencelabs/sqlite/releases/download/sqlite-wasm-v0.18.1/sqlite3.wasm -o artifacts/sqlite3.wasm
 
 # generate Aqua bindings
 marine aqua artifacts/trust-graph.wasm -s TrustGraph -i trust-graph > ../aqua/trust-graph.aqua

service/rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2022-01-16"
-targets = [ "x86_64-apple-darwin", "x86_64-unknown-linux-gnu" ]
+channel = "nightly-2022-12-06"
+targets = [ "x86_64-apple-darwin", "wasm32-wasi", "wasm32-unknown-unknown", "x86_64-unknown-linux-gnu" ]

service/src/dto.rs

@@ -1,7 +1,7 @@
 use crate::dto::DtoConversionError::PeerIdDecodeError;
 use fluence_keypair::error::DecodingError;
 use fluence_keypair::{KeyFormat, PublicKey, Signature};
-use libp2p_core::PeerId;
+use libp2p_identity::PeerId;
 use marine_rs_sdk::marine;
 use std::convert::TryFrom;
 use std::str::FromStr;
@@ -78,7 +78,7 @@ impl TryFrom<Trust> for trust_graph::Trust {
 
     fn try_from(t: Trust) -> Result<Self, Self::Error> {
         let issued_for = PublicKey::try_from(
-            PeerId::from_str(&t.issued_for).map_err(|e| PeerIdDecodeError(format!("{:?}", e)))?,
+            PeerId::from_str(&t.issued_for).map_err(|e| PeerIdDecodeError(format!("{e:?}")))?,
         )
         .map_err(|e| DtoConversionError::PeerIdDecodeError(e.to_string()))?;
         let signature = bs58::decode(&t.signature).into_vec()?;
@@ -132,11 +132,11 @@ impl TryFrom<Revocation> for trust_graph::Revocation {
     fn try_from(r: Revocation) -> Result<Self, Self::Error> {
         let revoked_pk = PublicKey::try_from(
             PeerId::from_str(&r.revoked_peer_id)
-                .map_err(|e| PeerIdDecodeError(format!("{:?}", e)))?,
+                .map_err(|e| PeerIdDecodeError(format!("{e:?}")))?,
         )
         .map_err(|e| DtoConversionError::PeerIdDecodeError(e.to_string()))?;
         let revoked_by_pk = PublicKey::try_from(
-            PeerId::from_str(&r.revoked_by).map_err(|e| PeerIdDecodeError(format!("{:?}", e)))?,
+            PeerId::from_str(&r.revoked_by).map_err(|e| PeerIdDecodeError(format!("{e:?}")))?,
         )
         .map_err(|e| DtoConversionError::PeerIdDecodeError(e.to_string()))?;
         let signature = bs58::decode(&r.signature).into_vec()?;

service/src/main.rs

@@ -13,31 +13,10 @@ mod results;
 mod service_api;
 mod storage_impl;
 mod tests;
-/*
-   _initialize function that calls __wasm_call_ctors is required to mitigade memory leak
-   that is described in https://github.com/WebAssembly/wasi-libc/issues/298
 
-   In short, without this code rust wraps every export function
-   with __wasm_call_ctors/__wasm_call_dtors calls. This causes memory leaks. When compiler sees
-   an explicit call to __wasm_call_ctors in _initialize function, it disables export wrapping.
-
-   TODO: remove when updating to marine-rs-sdk with fix
-*/
-extern "C" {
-    pub fn __wasm_call_ctors();
-}
-
-#[no_mangle]
-fn _initialize() {
-    unsafe {
-        __wasm_call_ctors();
-    }
-}
-//------------------------------
 pub static TRUSTED_TIMESTAMP: (&str, &str) = ("peer", "timestamp_sec");
 
 pub fn main() {
-    _initialize(); // As __wasm_call_ctors still does necessary work, we call it at the start of the module
     WasmLoggerBuilder::new()
         .with_log_level(log::LevelFilter::Trace)
         .build()

service/src/misc.rs

@@ -18,7 +18,7 @@ use crate::error::ServiceError::*;
 use crate::storage_impl::{SQLiteStorage, DB_PATH};
 use crate::TRUSTED_TIMESTAMP;
 use fluence_keypair::PublicKey;
-use libp2p_core::PeerId;
+use libp2p_identity::PeerId;
 use marine_rs_sdk::CallParameters;
 use std::cell::RefCell;
 use std::convert::TryFrom;
@@ -27,6 +27,7 @@ use std::str::FromStr;
 use trust_graph::TrustGraph;
 
 /// Check timestamps are generated on the current host with builtin ("peer" "timestamp_sec")
+#[allow(clippy::unnecessary_lazy_evaluations)]
 pub(crate) fn check_timestamp_tetraplets(
     call_parameters: &CallParameters,
     arg_number: usize,
@@ -41,12 +42,12 @@ pub(crate) fn check_timestamp_tetraplets(
     (TRUSTED_TIMESTAMP.eq(&(&tetraplet.service_id, &tetraplet.function_name))
         && tetraplet.peer_pk == call_parameters.host_id)
         .then(|| ())
-        .ok_or_else(|| InvalidTimestampTetraplet(format!("{:?}", tetraplet)))
+        .ok_or_else(|| InvalidTimestampTetraplet(format!("{tetraplet:?}")))
 }
 
 fn parse_peer_id(peer_id: String) -> Result<PeerId, ServiceError> {
-    libp2p_core::PeerId::from_str(&peer_id)
-        .map_err(|e| ServiceError::PeerIdParseError(format!("{:?}", e)))
+    libp2p_identity::PeerId::from_str(&peer_id)
+        .map_err(|e| ServiceError::PeerIdParseError(format!("{e:?}")))
 }
 
 thread_local!(static INSTANCE: RefCell<TrustGraph<SQLiteStorage>> = RefCell::new(TrustGraph::new(

service/src/results.rs

@@ -17,7 +17,7 @@ impl From<Result<(), ServiceError>> for InsertResult {
             },
             Err(e) => InsertResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -44,7 +44,7 @@ impl From<Result<(u32, String), ServiceError>> for WeightResult {
                 success: false,
                 weight: 0u32,
                 peer_id: "".to_string(),
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -68,7 +68,7 @@ impl From<Result<Vec<Certificate>, ServiceError>> for AllCertsResult {
             Err(e) => AllCertsResult {
                 success: false,
                 certificates: vec![],
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -89,7 +89,7 @@ impl From<Result<(), ServiceError>> for SetRootResult {
             },
             Err(e) => SetRootResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -112,7 +112,7 @@ impl From<Result<Vec<u8>, ServiceError>> for GetTrustBytesResult {
             },
             Err(e) => GetTrustBytesResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
                 result: vec![],
             },
         }
@@ -136,7 +136,7 @@ impl From<Result<Trust, ServiceError>> for IssueTrustResult {
             },
             Err(e) => IssueTrustResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
                 trust: Trust::default(),
             },
         }
@@ -158,7 +158,7 @@ impl From<Result<(), ServiceError>> for VerifyTrustResult {
             },
             Err(e) => VerifyTrustResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -181,7 +181,7 @@ impl From<Result<u32, ServiceError>> for AddTrustResult {
             },
             Err(e) => AddTrustResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
                 weight: u32::default(),
             },
         }
@@ -205,7 +205,7 @@ impl From<Result<Vec<u8>, ServiceError>> for GetRevokeBytesResult {
             },
             Err(e) => GetRevokeBytesResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
                 result: vec![],
             },
         }
@@ -229,7 +229,7 @@ impl From<Result<Revocation, ServiceError>> for IssueRevocationResult {
             },
             Err(e) => IssueRevocationResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
                 revocation: Revocation::default(),
             },
         }
@@ -251,7 +251,7 @@ impl From<Result<(), ServiceError>> for RevokeResult {
             },
             Err(e) => RevokeResult {
                 success: false,
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }
@@ -275,7 +275,7 @@ impl From<Result<Vec<Revocation>, ServiceError>> for ExportRevocationsResult {
             Err(e) => ExportRevocationsResult {
                 success: false,
                 revocations: vec![],
-                error: format!("{}", e),
+                error: format!("{e}"),
             },
         }
     }

service/src/storage_impl.rs

@@ -100,7 +100,7 @@ impl SQLiteStorage {
             .cursor();
 
         cursor.bind(&[
-            Value::String(format!("{}", issued_for)),
+            Value::String(format!("{issued_for}")),
             Value::Integer(relation_type),
         ])?;
         let mut relations: Vec<TrustRelation> = vec![];
@@ -206,8 +206,8 @@ impl Storage for SQLiteStorage {
             .cursor();
 
         cursor.bind(&[
-            Value::String(format!("{}", issued_by)),
-            Value::String(format!("{}", issued_for)),
+            Value::String(format!("{issued_by}")),
+            Value::String(format!("{issued_for}")),
         ])?;
 
         if let Some(row) = cursor.next()? {
@@ -281,7 +281,7 @@ impl Storage for SQLiteStorage {
             .prepare("SELECT public_key, weight_factor FROM roots WHERE public_key = ?")?
             .cursor();
 
-        cursor.bind(&[Value::String(format!("{}", pk))])?;
+        cursor.bind(&[Value::String(format!("{pk}"))])?;
 
         if let Some(row) = cursor.next()? {
             let w = u32::try_from(row[1].as_integer().ok_or(WeightFactorConversionDB)?)
@@ -304,7 +304,7 @@ impl Storage for SQLiteStorage {
             .cursor();
 
         cursor.bind(&[
-            Value::String(format!("{}", pk)),
+            Value::String(format!("{pk}")),
             Value::Integer(i64::from(weight_factor)),
         ])?;
 

service/src/tests.rs

@@ -18,18 +18,18 @@
 mod service_tests {
     marine_rs_sdk_test::include_test_env!("/marine_test_env.rs");
     use crate::error::ServiceError;
-    use crate::storage_impl::DB_PATH;
     use crate::TRUSTED_TIMESTAMP;
     use fluence_keypair::KeyPair;
-    use libp2p_core::PeerId;
+    use libp2p_identity::PeerId;
     use marine_rs_sdk::{CallParameters, SecurityTetraplet};
     use marine_test_env::trust_graph::{Certificate, Revocation, ServiceInterface, Trust};
-    use rusqlite::Connection;
     use std::collections::HashMap;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     static HOST_ID: &str = "some_host_id";
 
+    static TEST_DB_PATH: &str = "data/trust-graph.sqlite";
+
     struct Auth {
         issuer: PeerId,
         trust: Trust,
@@ -55,12 +55,7 @@ mod service_tests {
     }
 
     fn clear_env() {
-        let connection = Connection::open(DB_PATH).unwrap();
-
-        connection
-            .execute("DELETE FROM trust_relations", [])
-            .unwrap();
-        connection.execute("DELETE FROM roots", []).unwrap();
+        std::fs::remove_file(TEST_DB_PATH).unwrap_or_default();
     }
 
     fn get_correct_timestamp_cp(arg_number: usize) -> CallParameters {
@@ -445,32 +440,32 @@ mod service_tests {
         let mut trust_graph = marine_test_env::trust_graph::ServiceInterface::new();
         clear_env();
 
-        let peerA_kp = KeyPair::generate_ed25519();
+        let peer_a_kp = KeyPair::generate_ed25519();
         let mut cur_time = 100u64;
-        add_root_with_trust(&mut trust_graph, &peerA_kp, cur_time, cur_time + 9999, 10);
+        add_root_with_trust(&mut trust_graph, &peer_a_kp, cur_time, cur_time + 9999, 10);
 
-        let peerB_kp = KeyPair::generate_ed25519();
+        let peer_b_kp = KeyPair::generate_ed25519();
         add_trust(
             &mut trust_graph,
-            &peerA_kp,
-            &peerB_kp.get_peer_id(),
+            &peer_a_kp,
+            &peer_b_kp.get_peer_id(),
             cur_time,
             cur_time + 99999,
         );
 
-        let weight = get_weight(&mut trust_graph, peerB_kp.get_peer_id(), cur_time);
+        let weight = get_weight(&mut trust_graph, peer_b_kp.get_peer_id(), cur_time);
         assert_ne!(weight, 0u32);
 
         cur_time += 1;
         // A revokes B and cancels trust
         revoke(
             &mut trust_graph,
-            &peerA_kp,
-            &peerB_kp.get_peer_id(),
+            &peer_a_kp,
+            &peer_b_kp.get_peer_id(),
             cur_time,
         );
 
-        let weight = get_weight(&mut trust_graph, peerB_kp.get_peer_id(), cur_time);
+        let weight = get_weight(&mut trust_graph, peer_b_kp.get_peer_id(), cur_time);
         assert_eq!(weight, 0u32);
     }
 

trust-graph/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.10.0 to 0.10.1
+
+## [0.4.4](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.3...trust-graph-v0.4.4) (2023-05-09)
+
+
+### Features
+
+* fix trust-graph package ([#98](https://github.com/fluencelabs/trust-graph/issues/98)) ([a8fdb44](https://github.com/fluencelabs/trust-graph/commit/a8fdb4472ef1676724e4bfab1b4419f07faae2d9))
+
+## [0.4.3](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.2...trust-graph-v0.4.3) (2023-05-08)
+
+
+### Features
+
+* dummy change for release ([#95](https://github.com/fluencelabs/trust-graph/issues/95)) ([b6df3fe](https://github.com/fluencelabs/trust-graph/commit/b6df3fe5484b0adcad0c88abe170317a837142b3))
+
+## [0.4.1](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.0...trust-graph-v0.4.1) (2023-04-13)
+
+
+### Miscellaneous Chores
+
+* **trust-graph:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.0](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.3.2...trust-graph-v0.4.0) (2023-03-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77))
+
+### Features
+
+* **deps:** update libp2p to 0.39.1 and other deps ([#77](https://github.com/fluencelabs/trust-graph/issues/77)) ([080503d](https://github.com/fluencelabs/trust-graph/commit/080503dcfa2ecf8d09167ff9fe7f750fadf49035))
+* **keypair:** add KeyPair::from_secret_key ([#50](https://github.com/fluencelabs/trust-graph/issues/50)) ([a6ce8d9](https://github.com/fluencelabs/trust-graph/commit/a6ce8d9eee20e1ea24eb27c38ac6df6d878292ae))
+
+
+### Bug Fixes
+
+* **deps:** Update libp2p-core to 0.38 ([#51](https://github.com/fluencelabs/trust-graph/issues/51)) ([015422e](https://github.com/fluencelabs/trust-graph/commit/015422efcce41530a6cd84a25091598bc459d2e6))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.9.0 to 0.10.0

trust-graph/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "trust-graph"
+version = "0.4.4"
+authors = ["Fluence Labs"]
+edition = "2021"
+description = "trust graph"
+license = "Apache-2.0"
+repository = "https://github.com/fluencelabs/trust-graph"
+
+[dependencies]
+serde = { version = "1.0.118", features = ["derive"] }
+
+fluence-keypair = { path = "../keypair", version = "0.10.1" }
+bs58 = "0.4.0"
+failure = "0.1.6"
+log = "0.4.11"
+ref-cast = "1.0.2"
+derivative = "2.1.1"
+thiserror = "1.0.23"
+sha2 = "0.10.6"
+rand = "0.8.5"
+nonempty = "0.8.1"

trust-graph/src/certificate.rs

@@ -160,8 +160,8 @@ impl Certificate {
     ) -> Result<Self, CertificateError> {
         if expires_at.lt(&issued_at) {
             return Err(ExpirationError {
-                expires_at: format!("{:?}", expires_at),
-                issued_at: format!("{:?}", issued_at),
+                expires_at: format!("{expires_at:?}"),
+                issued_at: format!("{issued_at:?}"),
             });
         }
 

trust-graph/src/certificate_serde.rs

@@ -35,7 +35,7 @@ mod single {
     {
         let str = String::deserialize(deserializer)?;
         Certificate::from_str(&str)
-            .map_err(|e| Error::custom(format!("certificate deserialization failed for {:?}", e)))
+            .map_err(|e| Error::custom(format!("certificate deserialization failed for {e:?}")))
     }
 }
 
@@ -63,7 +63,7 @@ pub mod vec {
         v.into_iter()
             .map(|e| {
                 Certificate::from_str(&e).map_err(|e| {
-                    Error::custom(format!("certificate deserialization failed for {:?}", e))
+                    Error::custom(format!("certificate deserialization failed for {e:?}"))
                 })
             })
             .collect()

trust-graph/src/misc/mod.rs

@@ -5,6 +5,6 @@ pub fn current_time() -> Duration {
         SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap()
-            .as_secs() as u64,
+            .as_secs(),
     )
 }

trust-graph/src/public_key_hashable.rs

@@ -120,10 +120,10 @@ impl<'de> serde::Deserialize<'de> for PublicKeyHashable {
             {
                 bs58::decode(s)
                     .into_vec()
-                    .map_err(|err| Error::custom(format!("Invalid string '{}': {}", s, err)))
+                    .map_err(|err| Error::custom(format!("Invalid string '{s}': {err}")))
                     .and_then(|v| self.visit_bytes(v.as_slice()))
                     .map_err(|err: E| {
-                        Error::custom(format!("Parsed string '{}' as base58, but {}", s, err))
+                        Error::custom(format!("Parsed string '{s}' as base58, but {err}"))
                     })
             }
 
@@ -132,7 +132,7 @@ impl<'de> serde::Deserialize<'de> for PublicKeyHashable {
                 E: Error,
             {
                 let pk = PublicKey::decode(b)
-                    .map_err(|err| Error::custom(format!("Invalid bytes {:?}: {}", b, err)))?;
+                    .map_err(|err| Error::custom(format!("Invalid bytes {b:?}: {err}")))?;
                 Ok(PublicKeyHashable::from(pk))
             }
         }

trust-graph/src/revoke.rs

@@ -75,7 +75,7 @@ impl Revocation {
         let pk_bytes = &pk.encode();
         metadata.push(pk_bytes.len() as u8);
         metadata.extend(pk_bytes);
-        metadata.extend_from_slice(&(revoked_at.as_secs() as u64).to_le_bytes());
+        metadata.extend_from_slice(&revoked_at.as_secs().to_le_bytes());
 
         sha2::Sha256::digest(&metadata).to_vec()
     }

trust-graph/src/trust.rs

@@ -144,8 +144,8 @@ impl Trust {
 
     pub fn signature_bytes(pk: &PublicKey, expires_at: Duration, issued_at: Duration) -> Vec<u8> {
         let pk_encoded = pk.encode();
-        let expires_at_encoded: [u8; EXPIRATION_LEN] = (expires_at.as_secs() as u64).to_le_bytes();
-        let issued_at_encoded: [u8; ISSUED_LEN] = (issued_at.as_secs() as u64).to_le_bytes();
+        let expires_at_encoded: [u8; EXPIRATION_LEN] = expires_at.as_secs().to_le_bytes();
+        let issued_at_encoded: [u8; ISSUED_LEN] = issued_at.as_secs().to_le_bytes();
         let mut metadata = Vec::new();
 
         metadata.extend(pk_encoded);
@@ -165,8 +165,8 @@ impl Trust {
         vec.append(&mut issued_for);
         vec.push(signature.len() as u8);
         vec.append(&mut signature);
-        vec.extend_from_slice(&(self.expires_at.as_secs() as u64).to_le_bytes());
-        vec.extend_from_slice(&(self.issued_at.as_secs() as u64).to_le_bytes());
+        vec.extend_from_slice(&self.expires_at.as_secs().to_le_bytes());
+        vec.extend_from_slice(&self.issued_at.as_secs().to_le_bytes());
 
         vec
     }
@@ -260,13 +260,10 @@ impl ToString for Trust {
     fn to_string(&self) -> String {
         let issued_for = bs58::encode(self.issued_for.encode()).into_string();
         let signature = bs58::encode(self.signature.encode()).into_string();
-        let expires_at = (self.expires_at.as_secs() as u64).to_string();
-        let issued_at = (self.issued_at.as_secs() as u64).to_string();
+        let expires_at = self.expires_at.as_secs().to_string();
+        let issued_at = self.issued_at.as_secs().to_string();
 
-        format!(
-            "{}\n{}\n{}\n{}",
-            issued_for, signature, expires_at, issued_at
-        )
+        format!("{issued_for}\n{signature}\n{expires_at}\n{issued_at}")
     }
 }
 

trust-graph/src/trust_graph.rs

@@ -90,7 +90,7 @@ impl<T: StorageError + 'static> From<T> for TrustGraphError {
 
 impl From<TrustGraphError> for String {
     fn from(err: TrustGraphError) -> Self {
-        format!("{}", err)
+        format!("{err}")
     }
 }
 
@@ -374,8 +374,7 @@ where
                 // Certificate with one trust means nothing, gotta be a bug. Checking for it here.
                 debug_assert!(
                     c.chain.len() > 1,
-                    "certificate with chain of len 1 arose: {:#?}",
-                    c
+                    "certificate with chain of len 1 arose: {c:#?}",
                 );
                 c.chain.len() > 1
             })