chore: release master (#156)

Add echo

.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,40 @@
+{
+  "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",
+        "distro"
+      ]
+    }
+  ],
+  "packages": {
+    "trust-graph": {
+      "component": "trust-graph"
+    },
+    "aqua": {
+      "release-type": "node",
+      "component": "trust-graph-api"
+    },
+    "service": {
+      "component": "trust-graph-wasm"
+    },
+    "keypair": {
+      "component": "keypair"
+    },
+    "distro": {
+      "component": "distro"
+    }
+  }
+}

.github/release-please/manifest.json

@@ -0,0 +1,7 @@
+{
+  "trust-graph": "0.4.11",
+  "aqua": "0.4.11",
+  "service": "0.4.11",
+  "keypair": "0.10.4",
+  "distro": "0.4.11"
+}

.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,134 +1,159 @@
-name: "publish-release"
+name: "release"
 
 on:
   push:
-    tags:
-      - "v*"
+    branches:
+      - "master"
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
 
 jobs:
-  release:
-    name: "Publish"
-    runs-on: builder
+  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
+      - 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: Set env
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-
-      - uses: actions/setup-node@v3
+      - name: Import secrets
+        uses: hashicorp/vault-action@v2.4.3
         with:
-          node-version: "15"
-          registry-url: "https://registry.npmjs.org"
-          cache: npm
-          cache-dependency-path: "aqua/package-lock.json"
-
-      - run: mkdir -p ~/.bin
-      - run: echo "~/.bin" >> $GITHUB_PATH
+          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: Download marine
-        run: bash $GITHUB_WORKSPACE/.github/download_marine.sh
+      - name: Setup marine
+        uses: fluencelabs/setup-marine@v1
 
-      - name: Build trust-graph
-        working-directory: ./service
+      - name: Build
         run: ./build.sh
 
-      - name: Check Aqua compiles
-        working-directory: ./aqua
+      - name: Install cargo-workspaces
+        uses: baptiste0928/cargo-install@v1.3.0
+        with:
+          crate: cargo-workspaces
+
+      - name: Publish to crates.io
         run: |
-          npm i
-          npm run build
+          cargo ws publish \
+            --no-git-commit \
+            --allow-dirty \
+            --from-git \
+            --skip-published \
+            --yes
 
-      - name: Create distribution package
+      - 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
+
+      - name: Setup fcli
+        uses: fluencelabs/setup-fluence@v1
+        with:
+          artifact: fcli
+          version: unstable
+
+      - 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
+
+  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:
+          statuses: failure
+          dependencies: ${{ toJSON(needs) }}
+
+      - name: Log output
         run: |
-          ./builtin-package/package.sh
+          echo "statuses:" "${{ steps.status.outputs.statuses }}"
+          echo "jobs:" "${{ steps.status.outputs.jobs }}"
+          echo "found any?:" "${{ steps.status.outputs.found }}"
 
-      - name: Build Changelog
-        id: changelog
-        uses: mikepenz/release-changelog-builder-action@v1
+      - name: Import secrets
+        uses: hashicorp/vault-action@v2.4.3
         with:
-          configuration: ".github/workflows/changelog_config.json"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          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
 
-### Publish
-      - name: Release to GitHub
-        id: release
-        uses: softprops/action-gh-release@v1
+      - uses: ravsamhq/notify-slack-action@v2
+        if: steps.status.outputs.found == 'true'
         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;
-            }
-
-      - name: Update version in node-distro repo
-        uses: benc-uk/workflow-dispatch@v1
-        with:
-          workflow: update_service
-          repo: fluencelabs/node-distro
-          ref: 'main'
-          token: ${{ secrets.PERSONAL_TOKEN }}
-          inputs: '{
-            "name": "trust-graph",
-            "version": "${{ env.RELEASE_VERSION }}",
-            "url": "${{ steps.package-url.outputs.result }}",
-            "sha256": "${{ env.SHA256 }}"
-          }'
-
-      - name: Log notice
-        uses: actions/github-script@v4
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-              console.dir(core);
-              core.info("trust-graph was updated to ${{ env.RELEASE_VERSION }} in node-distro repo");
+          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
-    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 toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-
-      - name: Add wasm32-wasi target
-        run: rustup target add wasm32-wasi
-
-      - 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,69 @@
+name: Run tests with workflow_call
+
+on:
+  workflow_call:
+    inputs:
+      fcli-version:
+        description: "@fluencelabs/cli version"
+        type: string
+        default: "main"
+
+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
+        with:
+          artifact-name: marine
+
+      - name: Build
+        run: ./build.sh
+
+      - name: Run cargo clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: -Z unstable-options --all
+
+      - name: Setup nextest
+        uses: taiki-e/install-action@nextest
+
+      - name: Run cargo nextest
+        env:
+          NEXTEST_RETRIES: 10
+          NEXTEST_TEST_THREADS: 10
+        # exclude distro since at this point we don't have compiled wasms which are required for compilation
+        run: cargo nextest run --release --all-features --no-fail-fast --workspace --exclude trust-graph-distro
+
+      - 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"
+
+      - name: Setup fcli
+        uses: fluencelabs/setup-fluence@v1
+        with:
+          artifact: fcli
+          version: ${{ inputs.fcli-version }}
+
+      - run: npm i
+        working-directory: aqua
+
+      - run: npm run build
+        working-directory: aqua

.gitignore

@@ -2,6 +2,8 @@ service/target
 service/artifacts
 builtin-package/*.wasm
 trust-graph.tar.gz
+distro/trust-graph-service
+distro/target
 
 **/*.rs.bk
 **/.idea

Cargo.toml

@@ -1,34 +1,10 @@
-[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]
-serde = { version = "1.0.118", features = ["derive"] }
-
-fluence-keypair = { path = "./keypair", version = "0.8.1" }
-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"
+    "service",
+    "distro"
 ]
 
 [workspace.dependencies]
-libp2p-core = { version = "0.36", default-features = false, features = [ "secp256k1", "rsa" ] }
+libp2p-identity = { version = "0.2.1", default-features = false }

admin/aqua/export.aqua

@@ -1,19 +1,25 @@
-import "@fluencelabs/trust-graph/trust-graph.aqua"
+aqua Admin
+
+export timestamp_sec, get_trust_bytes, issue_trust
 export get_trust_bytes, issue_trust
 
+import "@fluencelabs/trust-graph/trust-graph.aqua"
 import "@fluencelabs/aqua-lib/builtin.aqua"
 
 func timestamp_sec(node: string) -> u64:
     on node:
         result <- Peer.timestamp_sec()
+
     <- result
 
 func get_trust_bytes(node: string, issued_for_peer_id: string, expires_at_sec: u64, issued_at_sec: u64) -> GetTrustBytesResult:
     on node:
         result <- TrustGraph.get_trust_bytes(issued_for_peer_id, expires_at_sec, issued_at_sec)
+    
     <- result
 
 func issue_trust(node: string, issued_for_peer_id: string, expires_at_sec: u64, issued_at_sec: u64, trust_bytes: []u8) ->IssueTrustResult:
     on node:
         result <- TrustGraph.issue_trust(issued_for_peer_id, expires_at_sec, issued_at_sec, trust_bytes)
+    
     <- result

admin/package.json

@@ -4,7 +4,7 @@
   "description": "A simple example of how to use trust-graph in TS",
   "main": "index.js",
   "scripts": {
-    "compile-aqua": "aqua -i aqua -o generated",
+    "compile-aqua": "fluence aqua -i aqua -o generated",
     "prebuild": "npm run compile-aqua",
     "build": "tsc",
     "start": "node dist/index.js",
@@ -13,12 +13,11 @@
   "author": "Fluence Labs",
   "license": "MIT",
   "dependencies": {
-    "@fluencelabs/aqua": "^0.9.1-374",
-    "@fluencelabs/aqua-lib": "^0.6.0",
+    "@fluencelabs/aqua-lib": "^0.9.0",
     "@fluencelabs/fluence": "^0.27.5",
-    "@fluencelabs/fluence-network-environment": "^1.0.13",
+    "@fluencelabs/fluence-network-environment": "^1.1.2",
     "@fluencelabs/trust-graph": "file:../aqua",
-    "bs58": "^4.0.1"
+    "bs58": "^5.0.0"
   },
   "devDependencies": {
     "typescript": "^4.4.3"

aqua/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Changelog
+
+## [0.4.11](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.10...trust-graph-api-v0.4.11) (2024-01-17)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.10](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.9...trust-graph-api-v0.4.10) (2024-01-03)
+
+
+### Features
+
+* **trust-graph:** Update aqua code ([#141](https://github.com/fluencelabs/trust-graph/issues/141)) ([175e51d](https://github.com/fluencelabs/trust-graph/commit/175e51d5db4d90dc6d884ce3113d68494da334a2))
+
+
+### Bug Fixes
+
+* **trust-graph:** Revert release 0.4.10 ([#153](https://github.com/fluencelabs/trust-graph/issues/153)) ([b263ce1](https://github.com/fluencelabs/trust-graph/commit/b263ce1fb13b937b629608ede35b6f436023dcac))
+
+## [0.4.9](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.8...trust-graph-api-v0.4.9) (2023-12-28)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.8](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.7...trust-graph-api-v0.4.8) (2023-12-20)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.7](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.6...trust-graph-api-v0.4.7) (2023-07-04)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.6](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.5...trust-graph-api-v0.4.6) (2023-06-30)
+
+
+### Reverts
+
+* release master ([#110](https://github.com/fluencelabs/trust-graph/issues/110)) ([d80a43b](https://github.com/fluencelabs/trust-graph/commit/d80a43bcff721aff8fadf3d2d5c252804ce27a6c))
+
+## [0.4.5](https://github.com/fluencelabs/trust-graph/compare/trust-graph-api-v0.4.4...trust-graph-api-v0.4.5) (2023-05-09)
+
+
+### Miscellaneous Chores
+
+* **trust-graph-api:** Synchronize trust-graph, wasm and api versions
+
+## [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/labelling.aqua

@@ -1,3 +1,7 @@
+aqua Labelling declares *
+
+export isFluencePeer
+
 import "misc.aqua"
 import get_host_certs_from from "trust-graph-api.aqua"
 
@@ -20,7 +24,7 @@ func isFluencePeer() -> ?bool, ?Error:
     fluence_root_peer_id = "12D3KooWNbZKaPWRZ8wgjGvrxdJFz9Fq5uVwkR6ERV1f74HhPdyB"
     label_peer_id = "12D3KooWM45u7AQxsb4MuQJNYT3NWHHMLU7JTbBV66RTfF3KSzdR"
 
-    result: ?bool
+    result: *bool
     error: *Error
     -- get all certs issued by `label_peer_id` to current host
     certs_result <- get_host_certs_from(label_peer_id)
@@ -32,8 +36,9 @@ func isFluencePeer() -> ?bool, ?Error:
                 if cert.chain!0.issued_for == fluence_root_peer_id:
                     if cert.chain!1.issued_for == label_peer_id:
                         result <<- true
-        if result == nil:
+        if result == []:
             result <<- false
     else:
         error <<- certs_result.error
+
     <- result, error

aqua/misc.aqua

@@ -1,3 +1,5 @@
+aqua Misc declares *
+
 import "trust-graph.aqua"
 
 alias Error: string

aqua/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@fluencelabs/trust-graph",
-  "version": "0.2.2",
+  "version": "0.4.11",
   "description": "Aqua Trust Graph API library",
   "files": [
     "*.aqua"
   ],
   "dependencies": {
-    "@fluencelabs/aqua-lib": "^0.5.2"
+    "@fluencelabs/aqua-lib": "^0.9.0"
   },
   "scripts": {
     "generate-aqua": "../service/build.sh",
-    "compile-aqua": "aqua -i . -o ./target/typescript",
+    "compile-aqua": "fluence aqua -i . -o ./target/typescript",
     "build": "npm run compile-aqua"
   },
   "repository": {
@@ -29,8 +29,5 @@
   "bugs": {
     "url": "https://github.com/fluencelabs/trust-graph/issues"
   },
-  "homepage": "https://github.com/fluencelabs/trust-graph#readme",
-  "devDependencies": {
-    "@fluencelabs/aqua": "^0.7.4-322"
-  }
+  "homepage": "https://github.com/fluencelabs/trust-graph#readme"
 }

aqua/trust-graph-api.aqua

@@ -1,3 +1,12 @@
+aqua TrustGraphApi declares *
+
+export set_root, issue_trust, import_trust
+export add_trust, add_root_trust, verify_trust
+export get_weight, get_weight_from, issue_revocation
+export import_revocation, revoke, get_host_certs_from
+export get_all_certs, get_all_certs_from, get_host_certs
+export insert_cert
+
 import Sig, Peer, PeerId from "@fluencelabs/aqua-lib/builtin.aqua"
 import "misc.aqua"
 import "trust-graph.aqua"
@@ -24,7 +33,7 @@ func issue_trust(issuer: PeerId, issued_for: PeerId, expires_at_sec: u64) -> ?Tr
         issued_at_sec <- Peer.timestamp_sec()
         bytes <- TrustGraph.get_trust_bytes(issued_for, expires_at_sec, issued_at_sec)
 
-    result: ?Trust
+    result: *Trust
     error: *Error
     if bytes.success:
         Sig issuer
@@ -41,6 +50,7 @@ func issue_trust(issuer: PeerId, issued_for: PeerId, expires_at_sec: u64) -> ?Tr
             error <<- sig_res.error!
     else:
         error <<- bytes.error
+
     <- result, error
 
 -- Call context: any node with registered `trust-graph` service
@@ -51,8 +61,9 @@ func import_trust(trust: Trust, issuer: PeerId) -> ?Error:
     error: *Error
     timestamp_sec <- Peer.timestamp_sec()
     add_result <- TrustGraph.add_trust(trust, issuer, timestamp_sec)
-    if add_result.success != true:
+    if !add_result.success:
         error <<- add_result.error
+
     <- error
 
 -- Call context: %init_peer_id%
@@ -70,6 +81,7 @@ func add_trust(node: PeerId, issuer: PeerId, issued_for: PeerId, expires_at_sec:
         on node:
             import_error <- import_trust(trust!, issuer)
             append_error(error, import_error)
+
     <- error
 
 -- Call context: %init_peer_id%
@@ -99,6 +111,7 @@ func add_root_trust(node: PeerId, peer_id: PeerId, max_chain_len: u32, expires_a
 func verify_trust(trust: Trust, issuer: PeerId) -> VerifyTrustResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.verify_trust(trust, issuer, timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -107,6 +120,7 @@ func verify_trust(trust: Trust, issuer: PeerId) -> VerifyTrustResult:
 func get_weight(peer_id: PeerId) -> WeightResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_weight(peer_id, timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -114,6 +128,7 @@ func get_weight(peer_id: PeerId) -> WeightResult:
 func get_weight_from(peer_id: PeerId, issuer: PeerId) -> WeightResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_weight_from(peer_id, issuer, timestamp_sec)
+
     <- result
 
 -- Call context: %init_peer_id%
@@ -127,7 +142,7 @@ func issue_revocation(revoked_by: PeerId, revoked: PeerId) -> ?Revocation, ?Erro
         issued_at_sec <- Peer.timestamp_sec()
         bytes <- TrustGraph.get_revocation_bytes(revoked, issued_at_sec)
 
-    result: ?Revocation
+    result: *Revocation
     error: *Error
     if bytes.success:
         Sig revoked_by
@@ -145,6 +160,7 @@ func issue_revocation(revoked_by: PeerId, revoked: PeerId) -> ?Revocation, ?Erro
             error <<- sig_res.error!
     else:
         error <<- bytes.error
+
     <- result, error
 
 -- Call context: any node with registered `trust-graph` service
@@ -155,7 +171,7 @@ func import_revocation(revocation: Revocation) -> ?Error:
     error: *Error
     timestamp_sec <- Peer.timestamp_sec()
     add_result <- TrustGraph.revoke(revocation, timestamp_sec)
-    if add_result.success != true:
+    if !add_result.success:
         error <<- add_result.error
 
     <- error
@@ -176,6 +192,7 @@ func revoke(node: PeerId, revoked_by: PeerId, revoked: PeerId) -> ?Error:
         on node:
            import_error <- import_revocation(revocation!)
            append_error(error, import_error)
+
     <- error
 
 -- Call context: any node with registered `trust-graph` service
@@ -183,6 +200,7 @@ func revoke(node: PeerId, revoked_by: PeerId, revoked: PeerId) -> ?Error:
 func get_host_certs_from(issuer: PeerId) -> AllCertsResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_host_certs_from(issuer, timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -190,6 +208,7 @@ func get_host_certs_from(issuer: PeerId) -> AllCertsResult:
 func get_all_certs(issued_for: PeerId) -> AllCertsResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_all_certs(issued_for, timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -197,6 +216,7 @@ func get_all_certs(issued_for: PeerId) -> AllCertsResult:
 func get_all_certs_from(issued_for: PeerId, issuer: PeerId) -> AllCertsResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_all_certs_from(issued_for, issuer, timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -204,6 +224,7 @@ func get_all_certs_from(issued_for: PeerId, issuer: PeerId) -> AllCertsResult:
 func get_host_certs() -> AllCertsResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.get_host_certs(timestamp_sec)
+
     <- result
 
 -- Call context: any node with registered `trust-graph` service
@@ -211,4 +232,5 @@ func get_host_certs() -> AllCertsResult:
 func insert_cert(certificate: Certificate) -> InsertResult:
     timestamp_sec <- Peer.timestamp_sec()
     result <- TrustGraph.insert_cert(certificate, timestamp_sec)
+    
     <- result

aqua/trust-graph.aqua

@@ -1,4 +1,4 @@
-module TrustGraph declares *
+aqua TrustGraph declares *
 
 data AddTrustResult:
   success: bool

build.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -o errexit -o nounset -o pipefail
+
+# set current working directory to script directory to run script from everywhere
+cd "$(dirname "$0")"
+
+./service/build.sh
+
+TARGET="distro/trust-graph-service/"
+
+mkdir -p "$TARGET"
+cp -v ./distro/init_certs.json service/artifacts/trust-graph.wasm service/artifacts/sqlite3.wasm distro/Config.toml "$TARGET"
+
+cd distro
+cargo build

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 ***"

distro/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+## [0.4.11](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.10...distro-v0.4.11) (2024-01-17)
+
+
+### Miscellaneous Chores
+
+* **distro:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.10](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.9...distro-v0.4.10) (2024-01-03)
+
+
+### Bug Fixes
+
+* **trust-graph:** Revert release 0.4.10 ([#153](https://github.com/fluencelabs/trust-graph/issues/153)) ([b263ce1](https://github.com/fluencelabs/trust-graph/commit/b263ce1fb13b937b629608ede35b6f436023dcac))
+
+## [0.4.9](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.8...distro-v0.4.9) (2023-12-28)
+
+
+### Bug Fixes
+
+* **deps:** update sqlite wasm ([#135](https://github.com/fluencelabs/trust-graph/issues/135)) ([c59451d](https://github.com/fluencelabs/trust-graph/commit/c59451de04ba79152fa8d600a7b456ab24766dd0))
+
+## [0.4.8](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.7...distro-v0.4.8) (2023-12-20)
+
+
+### Features
+
+* update marine sdk's, configs and sqlite connector ([#129](https://github.com/fluencelabs/trust-graph/issues/129)) ([0b66f4e](https://github.com/fluencelabs/trust-graph/commit/0b66f4e0536633879de46f69ac8391c72ece7e77))
+
+## [0.4.7](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.6...distro-v0.4.7) (2023-07-04)
+
+
+### Miscellaneous Chores
+
+* **distro:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.6](https://github.com/fluencelabs/trust-graph/compare/distro-v0.4.5...distro-v0.4.6) (2023-06-30)
+
+
+### Features
+
+* add distro crate [fixes NET-463] ([#93](https://github.com/fluencelabs/trust-graph/issues/93)) ([3ba3855](https://github.com/fluencelabs/trust-graph/commit/3ba3855892ae355962212a0a42099dd9f9820800))
+
+
+### Reverts
+
+* release master ([#110](https://github.com/fluencelabs/trust-graph/issues/110)) ([d80a43b](https://github.com/fluencelabs/trust-graph/commit/d80a43bcff721aff8fadf3d2d5c252804ce27a6c))

distro/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "trust-graph-distro"
+version = "0.4.11"
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+include = [ "/src", "build.rs", "Cargo.toml", "trust-graph-service"]
+description = "Distribution package for the trust-graph service"
+
+# See more keysand their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+maplit = "1.0.2"
+serde = "1.0.160"
+serde_json = "1.0.96"
+lazy_static = "1.4.0"
+
+[build-dependencies]
+built = "0.6.0"

distro/Config.toml

@@ -0,0 +1,15 @@
+modules_dir = "."
+total_memory_limit = "Infinity"
+
+[[module]]
+    name = "sqlite3"
+    logger_enabled = true
+
+    [module.wasi]
+        mapped_dirs = { "tmp" = "data" }
+[[module]]
+    name = "trust-graph"
+    logger_enabled = true
+
+    [module.wasi]
+        mapped_dirs = { "tmp" = "data" }

distro/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    built::write_built_file().expect("Failed to acquire build-time information")
+}

distro/src/lib.rs

@@ -0,0 +1,60 @@
+use lazy_static::lazy_static;
+use serde::{Deserialize, Serialize};
+
+#[cfg(not(feature = "cargo-clippy"))]
+pub const TRUST_GRAPH_WASM: &[u8] = include_bytes!("../trust-graph-service/trust-graph.wasm");
+#[cfg(feature = "cargo-clippy")]
+pub const TRUST_GRAPH_WASM: &[u8] = &[];
+
+#[cfg(not(feature = "cargo-clippy"))]
+pub const SQLITE_WASM: &[u8] = include_bytes!("../trust-graph-service/sqlite3.wasm");
+#[cfg(feature = "cargo-clippy")]
+pub const SQLITE_WASM: &[u8] = &[];
+
+#[cfg(not(feature = "cargo-clippy"))]
+pub const CONFIG: &[u8] = include_bytes!("../trust-graph-service/Config.toml");
+#[cfg(feature = "cargo-clippy")]
+pub const CONFIG: &[u8] = &[];
+
+#[cfg(not(feature = "cargo-clippy"))]
+pub const KRAS_CERTS_JSON: &str = include_str!("../trust-graph-service/init_certs.json");
+#[cfg(feature = "cargo-clippy")]
+pub const KRAS_CERTS_JSON: &str = "{}";
+
+pub mod build_info {
+    include!(concat!(env!("OUT_DIR"), "/built.rs"));
+}
+
+pub use build_info::PKG_VERSION as VERSION;
+
+pub fn modules() -> std::collections::HashMap<&'static str, &'static [u8]> {
+    maplit::hashmap! {
+        "sqlite3" => SQLITE_WASM,
+        "trust-graph" => TRUST_GRAPH_WASM,
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Certs {
+    pub root_node: String,
+    pub max_chain_length: u32,
+    pub certs: Vec<Cert>,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Cert {
+    pub chain: Vec<Trust>,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Trust {
+    pub issued_for: String,
+    pub expires_at: u64,
+    pub signature: String,
+    pub sig_type: String,
+    pub issued_at: u64,
+}
+
+lazy_static! {
+    pub static ref KRAS_CERTS: Certs = serde_json::from_str(KRAS_CERTS_JSON).unwrap();
+}

example/aqua/computation.aqua

@@ -1,3 +1,4 @@
+aqua Computation
 
 import "@fluencelabs/trust-graph/trust-graph-api.aqua"
 import "@fluencelabs/trust-graph/trust-graph.aqua"
@@ -12,20 +13,21 @@ service TrustedComputation("op"):
     identity(s: u64) -> u64
 
 func trusted_computation(node: string) -> ?u64, ?string:
-    result: ?u64
-    error: ?string
+    result: *u64
+    error: *string
     -- on our trusted relay
     on HOST_PEER_ID:
         -- get all certificates issued for given node by our client's peer id
-        certs_result <- get_all_certs_from(node, %init_peer_id%)
+        certs_result <- get_all_certs_from(node, INIT_PEER_ID)
         if certs_result.success:
             len <- CertOp.array_length(certs_result.certificates)
         -- if there is any certificate node is trusted and computation is possible
-           if len != 0:
+            if len != 0:
                 on node:
                     result <- TrustedComputation.identity(5)
             else:
                 error <<- "there is no certs for this peer"
         else:
             error <<- certs_result.error
+
     <- result, error

example/aqua/export.aqua

@@ -1,11 +1,14 @@
-module Export
+aqua  Export
+
 import add_root_trust, add_trust, revoke from "@fluencelabs/trust-graph/trust-graph-api.aqua"
-export add_root_trust, add_trust, revoke, timestamp_sec
 import Peer from "@fluencelabs/aqua-lib/builtin.aqua"
 
+export add_root_trust, add_trust, revoke, timestamp_sec
+
 alias PeerId: string
 
 func timestamp_sec() -> u64:
     on HOST_PEER_ID:
         result <- Peer.timestamp_sec()
+
     <- result

example/package.json

@@ -4,7 +4,7 @@
   "description": "A simple example of how to use trust-graph in TS",
   "main": "index.js",
   "scripts": {
-    "compile-aqua": "aqua -i aqua -o generated",
+    "compile-aqua": "fluence aqua -i aqua -o generated",
     "prebuild": "npm run compile-aqua",
     "build": "tsc",
     "start": "node dist/index.js",
@@ -13,14 +13,14 @@
   "author": "Fluence Labs",
   "license": "MIT",
   "dependencies": {
-    "@fluencelabs/aqua-lib": "^0.5.2",
+    "@fluencelabs/aqua-lib": "^0.9.0",
     "@fluencelabs/fluence": "^0.23.0",
-    "@fluencelabs/fluence-network-environment": "^1.0.10",
-    "@fluencelabs/trust-graph": "3.0.2",
-    "bs58": "^4.0.1"
+    "@fluencelabs/fluence-network-environment": "^1.1.2",
+    "@fluencelabs/trust-graph": "3.1.2",
+    "bs58": "^5.0.0"
   },
   "devDependencies": {
     "typescript": "^4.5.2",
-    "@fluencelabs/aqua": "^0.7.4-325"
+    "@fluencelabs/aqua": "^0.10.0"
   }
 }

keypair/CHANGELOG.md

@@ -4,6 +4,57 @@ 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.4](https://github.com/fluencelabs/trust-graph/compare/keypair-v0.10.3...keypair-v0.10.4) (2023-12-20)
+
+
+### Features
+
+* **fluence-keypair:** bump ed25519-dalek to 0.2.0 ([#127](https://github.com/fluencelabs/trust-graph/issues/127)) ([ed5bd2c](https://github.com/fluencelabs/trust-graph/commit/ed5bd2c0ec50bef5ac7a12deacb73da491666912))
+* update marine sdk's, configs and sqlite connector ([#129](https://github.com/fluencelabs/trust-graph/issues/129)) ([0b66f4e](https://github.com/fluencelabs/trust-graph/commit/0b66f4e0536633879de46f69ac8391c72ece7e77))
+
+## [0.10.3](https://github.com/fluencelabs/trust-graph/compare/keypair-v0.10.2...keypair-v0.10.3) (2023-07-04)
+
+
+### Bug Fixes
+
+* **keypair:** deserialize libp2p keypair from secret key ([#116](https://github.com/fluencelabs/trust-graph/issues/116)) ([ee330a7](https://github.com/fluencelabs/trust-graph/commit/ee330a715a902e48fc9b61d662ffcd950a26379c))
+
+## [0.10.2](https://github.com/fluencelabs/trust-graph/compare/keypair-v0.10.1...keypair-v0.10.2) (2023-06-30)
+
+
+### Features
+
+* update libp2p identity  ([#109](https://github.com/fluencelabs/trust-graph/issues/109)) ([d04120b](https://github.com/fluencelabs/trust-graph/commit/d04120bacf802a7e1127f4955b7391b0a4353128))
+
+
+### Bug Fixes
+
+* **keypair:** update description ([#105](https://github.com/fluencelabs/trust-graph/issues/105)) ([f7ef0f8](https://github.com/fluencelabs/trust-graph/commit/f7ef0f8da095fe1fef80faaa0b0c2d5ef854bd16))
+
+
+### Reverts
+
+* release master ([#110](https://github.com/fluencelabs/trust-graph/issues/110)) ([d80a43b](https://github.com/fluencelabs/trust-graph/commit/d80a43bcff721aff8fadf3d2d5c252804ce27a6c))
+
+## [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

keypair/Cargo.toml

@@ -1,33 +1,30 @@
 [package]
 name = "fluence-keypair"
-version = "0.8.1"
+version = "0.10.4"
 authors = ["Fluence Labs"]
-edition = "2018"
-description = "identity"
+edition = "2021"
+description = "unified keypair API based on libp2p-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"
-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"
+bs58 = "0.5.0"
+ed25519-dalek = { version = "2.0.0", features = ["serde", "std", "rand_core"] }
+rand = "0.8.5"
 thiserror = "1.0.23"
-lazy_static = "1.2"
+lazy_static = "1.4"
 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 = { workspace = true }
 eyre = "0.6.5"
+libp2p-identity = { workspace = true, default-features = false, features = ["peerid", "rsa", "ed25519", "secp256k1"] }
+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-08-30"
+channel = "nightly-2023-12-06"
 targets = [ "x86_64-apple-darwin", "x86_64-unknown-linux-gnu" ]

keypair/src/ed25519.rs

@@ -19,16 +19,16 @@
 // DEALINGS IN THE SOFTWARE.
 
 //! Ed25519 keys.
-use crate::error::{DecodingError, SigningError, VerificationError};
+use crate::error::{DecodingError, DecodingError::InvalidLength, SigningError, VerificationError};
 use core::fmt;
 use ed25519_dalek::{self as ed25519, Signer as _, Verifier as _};
-use rand::RngCore;
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use zeroize::Zeroize;
 
-/// An Ed25519 keypair.
-pub struct Keypair(ed25519::Keypair);
+/// An Ed25519 keypair
+#[derive(Clone)]
+pub struct Keypair(ed25519::SigningKey);
 
 impl Keypair {
     /// Generate a new Ed25519 keypair.
@@ -40,13 +40,15 @@ impl Keypair {
     /// of the secret scalar and the compressed public point,
     /// an informal standard for encoding Ed25519 keypairs.
     pub fn encode(&self) -> [u8; 64] {
-        self.0.to_bytes()
+        self.0.to_keypair_bytes()
     }
 
     /// Decode a keypair from the format produced by `encode`,
     /// zeroing the input on success.
     pub fn decode(kp: &mut [u8]) -> Result<Self, DecodingError> {
-        ed25519::Keypair::from_bytes(kp)
+        let bytes = <[u8; 64]>::try_from(&*kp).map_err(InvalidLength)?;
+
+        ed25519::SigningKey::from_keypair_bytes(&bytes)
             .map(|k| {
                 kp.zeroize();
                 Keypair(k)
@@ -61,12 +63,12 @@ impl Keypair {
 
     /// Get the public key of this keypair.
     pub fn public(&self) -> PublicKey {
-        PublicKey(self.0.public)
+        PublicKey(self.0.verifying_key())
     }
 
     /// Get the secret key of this keypair.
     pub fn secret(&self) -> SecretKey {
-        SecretKey::from_bytes(&mut self.0.secret.to_bytes())
+        SecretKey::from_bytes(&mut self.0.to_bytes())
             .expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
     }
 }
@@ -74,26 +76,14 @@ impl Keypair {
 impl fmt::Debug for Keypair {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Keypair")
-            .field("public", &self.0.public)
+            .field("public", &self.0.verifying_key())
             .finish()
     }
 }
 
-impl Clone for Keypair {
-    fn clone(&self) -> Self {
-        let mut sk_bytes = self.0.secret.to_bytes();
-        let secret = SecretKey::from_bytes(&mut sk_bytes)
-            .expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
-            .0;
-        let public = ed25519::PublicKey::from_bytes(&self.0.public.to_bytes())
-            .expect("ed25519::PublicKey::from_bytes(to_bytes(k)) != k");
-        Keypair(ed25519::Keypair { secret, public })
-    }
-}
-
 /// Build keypair from existing ed25519 keypair
-impl From<ed25519::Keypair> for Keypair {
-    fn from(kp: ed25519::Keypair) -> Self {
+impl From<ed25519::SigningKey> for Keypair {
+    fn from(kp: ed25519::SigningKey) -> Self {
         Keypair(kp)
     }
 }
@@ -101,25 +91,21 @@ impl From<ed25519::Keypair> for Keypair {
 /// Demote an Ed25519 keypair to a secret key.
 impl From<Keypair> for SecretKey {
     fn from(kp: Keypair) -> Self {
-        SecretKey(kp.0.secret)
+        SecretKey(kp.0.to_bytes())
     }
 }
 
 /// Promote an Ed25519 secret key into a keypair.
 impl From<SecretKey> for Keypair {
     fn from(sk: SecretKey) -> Self {
-        let secret: ed25519::ExpandedSecretKey = (&sk.0).into();
-        let public = ed25519::PublicKey::from(&secret);
-        Keypair(ed25519::Keypair {
-            secret: sk.0,
-            public,
-        })
+        let signing = ed25519::SigningKey::from_bytes(&sk.0);
+        Keypair(signing)
     }
 }
 
 /// An Ed25519 public key.
 #[derive(PartialEq, Eq, Debug, Clone, Deserialize, Serialize)]
-pub struct PublicKey(ed25519::PublicKey);
+pub struct PublicKey(ed25519::VerifyingKey);
 
 impl PublicKey {
     /// Verify the Ed25519 signature on a message using the public key.
@@ -143,26 +129,21 @@ impl PublicKey {
 
     /// Decode a public key from a byte array as produced by `encode`.
     pub fn decode(bytes: &[u8]) -> Result<Self, DecodingError> {
-        ed25519::PublicKey::from_bytes(bytes)
+        let bytes = <[u8; 32]>::try_from(bytes).map_err(InvalidLength)?;
+        ed25519::VerifyingKey::from_bytes(&bytes)
             .map_err(DecodingError::Ed25519)
             .map(PublicKey)
     }
 }
 
 /// An Ed25519 secret key.
+#[derive(Clone)]
 pub struct SecretKey(pub ed25519::SecretKey);
 
 /// View the bytes of the secret key.
 impl AsRef<[u8]> for SecretKey {
     fn as_ref(&self) -> &[u8] {
-        self.0.as_bytes()
-    }
-}
-
-impl Clone for SecretKey {
-    fn clone(&self) -> Self {
-        let mut sk_bytes = self.0.to_bytes();
-        Self::from_bytes(&mut sk_bytes).expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
+        &self.0[..]
     }
 }
 
@@ -175,13 +156,8 @@ impl fmt::Debug for SecretKey {
 impl SecretKey {
     /// Generate a new Ed25519 secret key.
     pub fn generate() -> Self {
-        let mut bytes = [0u8; 32];
-        rand::thread_rng().fill_bytes(&mut bytes);
-        SecretKey(
-            ed25519::SecretKey::from_bytes(&bytes).expect(
-                "this returns `Err` only if the length is wrong; the length is correct; qed",
-            ),
-        )
+        let signing = ed25519::SigningKey::generate(&mut rand::rngs::OsRng);
+        SecretKey(signing.to_bytes())
     }
 
     /// Create an Ed25519 secret key from a byte slice, zeroing the input on success.
@@ -189,7 +165,7 @@ impl SecretKey {
     /// returned.
     pub fn from_bytes(mut sk_bytes: impl AsMut<[u8]>) -> Result<Self, DecodingError> {
         let sk_bytes = sk_bytes.as_mut();
-        let secret = ed25519::SecretKey::from_bytes(&*sk_bytes).map_err(DecodingError::Ed25519)?;
+        let secret = <[u8; 32]>::try_from(&*sk_bytes).map_err(InvalidLength)?;
         sk_bytes.zeroize();
         Ok(SecretKey(secret))
     }
@@ -201,10 +177,11 @@ pub struct Signature(pub Vec<u8>);
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::KeyPair;
     use quickcheck::*;
 
     fn eq_keypairs(kp1: &Keypair, kp2: &Keypair) -> bool {
-        kp1.public() == kp2.public() && kp1.0.secret.as_bytes() == kp2.0.secret.as_bytes()
+        kp1.public() == kp2.public() && kp1.0.to_bytes() == kp2.0.to_bytes()
     }
 
     #[test]
@@ -218,11 +195,22 @@ mod tests {
         QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
     }
 
+    #[test]
+    fn ed25519_keypair_convert() {
+        fn prop() -> bool {
+            let kp1 = KeyPair::generate_ed25519();
+            let libp2p_kp: libp2p_identity::Keypair = kp1.clone().into();
+            let kp2: KeyPair = libp2p_kp.into();
+            kp1.public() == kp2.public() && kp1.secret().unwrap() == kp2.secret().unwrap()
+        }
+        QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
+    }
+
     #[test]
     fn ed25519_keypair_from_secret() {
         fn prop() -> bool {
             let kp1 = Keypair::generate();
-            let mut sk = kp1.0.secret.to_bytes();
+            let mut sk = kp1.0.to_bytes();
             let kp2 = Keypair::from(SecretKey::from_bytes(&mut sk).unwrap());
             eq_keypairs(&kp1, &kp2) && sk == [0u8; 32]
         }

keypair/src/error.rs

@@ -31,6 +31,8 @@ pub enum Error {
 /// An error during decoding of key material.
 #[derive(ThisError, Debug)]
 pub enum DecodingError {
+    #[error("Failed to decode, invalid length: {0}")]
+    InvalidLength(#[from] std::array::TryFromSliceError),
     #[error("Failed to decode with ed25519: {0}")]
     Ed25519(
         #[from]

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::{KeyType, Keypair, PeerId};
 use std::convert::TryFrom;
 use std::str::FromStr;
 
@@ -47,7 +47,7 @@ use std::str::FromStr;
 /// let keypair = Keypair::rsa_from_pkcs8(&mut bytes);
 /// ```
 ///
-
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyFormat {
     Ed25519,
     #[cfg(not(target_arch = "wasm32"))]
@@ -105,6 +105,7 @@ impl From<KeyFormat> for String {
         }
     }
 }
+
 #[derive(Clone)]
 pub enum KeyPair {
     /// An Ed25519 keypair.
@@ -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::*;
@@ -182,7 +195,7 @@ impl KeyPair {
     pub fn secret(&self) -> eyre::Result<Vec<u8>> {
         use KeyPair::*;
         match self {
-            Ed25519(pair) => Ok(pair.secret().0.to_bytes().to_vec()),
+            Ed25519(pair) => Ok(pair.secret().0.to_vec()),
             #[cfg(not(target_arch = "wasm32"))]
             Rsa(_) => Err(eyre::eyre!("secret key is not available for RSA")),
             Secp256k1(pair) => Ok(pair.secret().to_bytes().to_vec()),
@@ -235,42 +248,65 @@ impl KeyPair {
     }
 }
 
-impl From<libp2p_core::identity::Keypair> for KeyPair {
-    fn from(key: libp2p_core::identity::Keypair) -> Self {
-        use libp2p_core::identity::Keypair::*;
-
-        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)
-            }),
-            Secp256k1(kp) => KeyPair::Secp256k1(secp256k1::Keypair::from(
-                secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
-            )),
+impl From<libp2p_identity::Keypair> for KeyPair {
+    fn from(key: libp2p_identity::Keypair) -> Self {
+        fn convert_keypair(key: Keypair) -> eyre::Result<KeyPair> {
+            match key.key_type() {
+                KeyType::Ed25519 => {
+                    let kp = key.try_into_ed25519()?;
+                    let raw_kp = ed25519::Keypair::decode(&mut kp.to_bytes())?;
+                    Ok(KeyPair::Ed25519(raw_kp))
+                }
+                #[cfg(not(target_arch = "wasm32"))]
+                KeyType::RSA => {
+                    let kp = key.try_into_rsa()?;
+                    let raw_kp = unsafe {
+                        std::mem::transmute::<libp2p_identity::rsa::Keypair, rsa::Keypair>(kp)
+                    };
+                    Ok(KeyPair::Rsa(raw_kp))
+                }
+                KeyType::Secp256k1 => {
+                    let kp = key.try_into_secp256k1()?;
+                    let raw_kp = secp256k1::SecretKey::from_bytes(kp.secret().to_bytes())?;
+                    Ok(KeyPair::Secp256k1(secp256k1::Keypair::from(raw_kp)))
+                }
+                _ => unreachable!(),
+            }
         }
+
+        convert_keypair(key).expect("Could not convert 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 KeyPair::*;
-
-        match key {
-            Ed25519(kp) => Keypair::Ed25519(
-                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)
-            }),
-            Secp256k1(kp) => Keypair::Secp256k1(identity::secp256k1::Keypair::from(
-                identity::secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
-            )),
+        fn convert_keypair(key: KeyPair) -> eyre::Result<libp2p_identity::Keypair> {
+            match key {
+                KeyPair::Ed25519(kp) => {
+                    // for some reason, libp2p takes SecretKey's 32 bytes here instead of Keypair's 64 bytes
+                    let secret_bytes = kp.secret().0;
+                    let kp = libp2p_identity::Keypair::ed25519_from_bytes(secret_bytes)?;
+                    Ok(kp)
+                }
+                #[cfg(not(target_arch = "wasm32"))]
+                // safety: these Keypair structures are identical
+                KeyPair::Rsa(kp) => {
+                    let kp = unsafe {
+                        std::mem::transmute::<rsa::Keypair, libp2p_identity::rsa::Keypair>(kp)
+                    };
+                    let kp = Keypair::from(kp);
+                    Ok(kp)
+                }
+                KeyPair::Secp256k1(kp) => {
+                    let sk = libp2p_identity::secp256k1::SecretKey::try_from_bytes(
+                        kp.secret().to_bytes(),
+                    )?;
+                    let kp = libp2p_identity::secp256k1::Keypair::from(sk);
+                    let kp = Keypair::from(kp);
+                    Ok(kp)
+                }
+            }
         }
+        convert_keypair(key).expect("Could not convert key pair")
     }
 }

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::{KeyType, PeerId};
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
@@ -124,46 +124,67 @@ impl PublicKey {
     }
 }
 
-impl From<libp2p_core::identity::PublicKey> for PublicKey {
-    fn from(key: libp2p_core::identity::PublicKey) -> Self {
-        use libp2p_core::identity::PublicKey::*;
-
-        match key {
-            Ed25519(key) => {
-                PublicKey::Ed25519(ed25519::PublicKey::decode(&key.encode()[..]).unwrap())
-            }
-            #[cfg(not(target_arch = "wasm32"))]
-            Rsa(key) => PublicKey::Rsa(rsa::PublicKey::from_pkcs1(key.encode_pkcs1()).unwrap()),
-            Secp256k1(key) => {
-                PublicKey::Secp256k1(secp256k1::PublicKey::decode(&key.encode()[..]).unwrap())
+impl From<libp2p_identity::PublicKey> for PublicKey {
+    fn from(key: libp2p_identity::PublicKey) -> Self {
+        fn convert_key(key: libp2p_identity::PublicKey) -> eyre::Result<PublicKey> {
+            match key.key_type() {
+                KeyType::Ed25519 => {
+                    let pk = key.try_into_ed25519()?;
+                    let raw_pk = ed25519::PublicKey::decode(&pk.to_bytes())?;
+                    Ok(PublicKey::Ed25519(raw_pk))
+                }
+                #[cfg(not(target_arch = "wasm32"))]
+                KeyType::RSA => {
+                    let pk = key.try_into_rsa()?;
+                    let raw_pk = rsa::PublicKey::from_pkcs1(pk.encode_pkcs1())?;
+                    Ok(PublicKey::Rsa(raw_pk))
+                }
+                KeyType::Secp256k1 => {
+                    let pk = key.try_into_secp256k1()?;
+                    let raw_pk = secp256k1::PublicKey::decode(&pk.to_bytes())?;
+                    Ok(PublicKey::Secp256k1(raw_pk))
+                }
+                _ => unreachable!(),
             }
         }
+
+        convert_key(key).expect("Could not convert public key")
     }
 }
 
-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;
-
-        match key {
-            PublicKey::Ed25519(key) => libp2p_identity::PublicKey::Ed25519(
-                libp2p_identity::ed25519::PublicKey::decode(&key.encode()[..]).unwrap(),
-            ),
-            #[cfg(not(target_arch = "wasm32"))]
-            PublicKey::Rsa(key) => libp2p_identity::PublicKey::Rsa(
-                libp2p_identity::rsa::PublicKey::decode_x509(&key.encode_x509()).unwrap(),
-            ),
-            PublicKey::Secp256k1(key) => libp2p_identity::PublicKey::Secp256k1(
-                libp2p_identity::secp256k1::PublicKey::decode(&key.encode()[..]).unwrap(),
-            ),
+        fn convert_key(key: PublicKey) -> eyre::Result<libp2p_identity::PublicKey> {
+            match key {
+                PublicKey::Ed25519(key) => {
+                    let raw_pk =
+                        libp2p_identity::ed25519::PublicKey::try_from_bytes(&key.encode())?;
+                    let pk = libp2p_identity::PublicKey::from(raw_pk);
+                    Ok(pk)
+                }
+                #[cfg(not(target_arch = "wasm32"))]
+                PublicKey::Rsa(key) => {
+                    let raw_pk =
+                        libp2p_identity::rsa::PublicKey::try_decode_x509(&key.encode_x509())?;
+                    let pk = libp2p_identity::PublicKey::from(raw_pk);
+                    Ok(pk)
+                }
+                PublicKey::Secp256k1(key) => {
+                    let raw_pk =
+                        libp2p_identity::secp256k1::PublicKey::try_from_bytes(&key.encode())?;
+                    let pk = libp2p_identity::PublicKey::from(raw_pk);
+                    Ok(pk)
+                }
+            }
         }
+        convert_key(key).expect("Could not convert key")
     }
 }
 
-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 +192,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::try_decode_protobuf(mhash.digest()).ok()
         }
         _ => None,
     }
@@ -209,8 +228,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

@@ -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> =
@@ -229,6 +229,12 @@ pub struct Signature(pub Vec<u8>);
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::{key_pair, KeyFormat};
+    use quickcheck::QuickCheck;
+
+    fn eq_keypairs(kp1: key_pair::KeyPair, kp2: key_pair::KeyPair) -> bool {
+        kp1.public() == kp2.public() && kp1.secret().unwrap() == kp2.secret().unwrap()
+    }
 
     #[test]
     fn secp256k1_secret_from_bytes() {
@@ -239,4 +245,15 @@ mod tests {
         assert_eq!(sk1.0.serialize(), sk2.0.serialize());
         assert_eq!(sk_bytes, [0; 32]);
     }
+
+    #[test]
+    fn secp256k1_keypair_encode_decode() {
+        fn prop() -> bool {
+            let kp1 = key_pair::KeyPair::generate(KeyFormat::Secp256k1);
+            let kp1_enc = libp2p_identity::Keypair::from(kp1.clone());
+            let kp2 = key_pair::KeyPair::from(kp1_enc);
+            eq_keypairs(kp1, kp2)
+        }
+        QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
+    }
 }

rust-toolchain.toml

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

service/CHANGELOG.md

@@ -4,6 +4,174 @@ 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.11](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.10...trust-graph-wasm-v0.4.11) (2024-01-17)
+
+
+### Bug Fixes
+
+* **trust-graph:** Regenerate aqua bindings from wasm ([#155](https://github.com/fluencelabs/trust-graph/issues/155)) ([fd145c5](https://github.com/fluencelabs/trust-graph/commit/fd145c5fe1a115e87539ec5c9496d8b4c8bbc468))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.10 to 0.4.11
+
+## [0.4.10](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.9...trust-graph-wasm-v0.4.10) (2024-01-03)
+
+
+### Bug Fixes
+
+* **trust-graph:** Revert release 0.4.10 ([#153](https://github.com/fluencelabs/trust-graph/issues/153)) ([b263ce1](https://github.com/fluencelabs/trust-graph/commit/b263ce1fb13b937b629608ede35b6f436023dcac))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.9 to 0.4.10
+
+## [0.4.9](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.8...trust-graph-wasm-v0.4.9) (2023-12-28)
+
+
+### Bug Fixes
+
+* **deps:** update sqlite wasm ([#135](https://github.com/fluencelabs/trust-graph/issues/135)) ([c59451d](https://github.com/fluencelabs/trust-graph/commit/c59451de04ba79152fa8d600a7b456ab24766dd0))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.8 to 0.4.9
+
+## [0.4.8](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.7...trust-graph-wasm-v0.4.8) (2023-12-20)
+
+
+### Features
+
+* update marine sdk's, configs and sqlite connector ([#129](https://github.com/fluencelabs/trust-graph/issues/129)) ([0b66f4e](https://github.com/fluencelabs/trust-graph/commit/0b66f4e0536633879de46f69ac8391c72ece7e77))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.7 to 0.4.8
+    * fluence-keypair bumped from 0.10.3 to 0.10.4
+
+## [0.4.7](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.6...trust-graph-wasm-v0.4.7) (2023-07-04)
+
+
+### Bug Fixes
+
+* **deps:** update rust crate marine-rs-sdk-test to 0.10.0 ([#106](https://github.com/fluencelabs/trust-graph/issues/106)) ([725d3f8](https://github.com/fluencelabs/trust-graph/commit/725d3f8f48b3bf1ed8605e9ba2da5c966a145f0d))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.6 to 0.4.7
+    * fluence-keypair bumped from 0.10.2 to 0.10.3
+
+## [0.4.6](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.5...trust-graph-wasm-v0.4.6) (2023-06-30)
+
+
+### Reverts
+
+* release master ([#110](https://github.com/fluencelabs/trust-graph/issues/110)) ([d80a43b](https://github.com/fluencelabs/trust-graph/commit/d80a43bcff721aff8fadf3d2d5c252804ce27a6c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * trust-graph bumped from 0.4.5 to 0.4.6
+    * fluence-keypair bumped from 0.10.1 to 0.10.2
+
+## [0.4.5](https://github.com/fluencelabs/trust-graph/compare/trust-graph-wasm-v0.4.4...trust-graph-wasm-v0.4.5) (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.4 to 0.4.5
+
+## [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

service/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "trust-graph-wasm"
-version = "0.3.1"
+version = "0.4.11"
 authors = ["Fluence Labs"]
-edition = "2018"
+edition = "2021"
 description = "trust graph wasm"
 license = "Apache-2.0"
 publish = false
@@ -12,28 +12,25 @@ name = "trust-graph"
 path = "src/main.rs"
 
 [dependencies]
-trust-graph = { version = "0.3.0", path = "../." }
-fluence-keypair = { version = "0.8.1", path = "../keypair" }
-marine-rs-sdk = { version = "0.6.14", features = ["logger"] }
-marine-sqlite-connector = "0.5.2"
+trust-graph = { version = "0.4.11", path = "../trust-graph" }
+fluence-keypair = { version = "0.10.4", path = "../keypair" }
+marine-rs-sdk = { version = "0.10.2", features = ["logger"] }
+marine-sqlite-connector = "0.9.2"
 
-libp2p-core = { workspace = true }
+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"
+once_cell = "1.18.0"
 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.12.1"
+rusqlite = "0.28.0"
 
 [build-dependencies]
-marine-rs-sdk-test = "0.4.0"
+marine-rs-sdk-test = "0.12.1"

service/Config.toml

@@ -1,16 +1,15 @@
 modules_dir = "artifacts/"
+total_memory_limit = "Infinity"
 
 [[module]]
     name = "sqlite3"
     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

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
+
 set -o errexit -o nounset -o pipefail
+set -x
 
 # set current working directory to script directory to run script from everywhere
 cd "$(dirname "$0")"
@@ -13,7 +15,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.2/sqlite3.wasm -o artifacts/sqlite3.wasm
 
-# # generate Aqua bindings
-# marine aqua artifacts/trust-graph.wasm -s TrustGraph -i trust-graph > ../aqua/trust-graph.aqua
+# 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-12-06"
+channel = "nightly-2023-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,
@@ -36,17 +37,17 @@ pub(crate) fn check_timestamp_tetraplets(
         .get(arg_number)
         .ok_or_else(|| InvalidTimestampTetraplet(format!("{:?}", call_parameters.tetraplets)))?;
     let tetraplet = tetraplets
-        .get(0)
+        .first()
         .ok_or_else(|| InvalidTimestampTetraplet(format!("{:?}", call_parameters.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,126 @@
+# Changelog
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.10.0 to 0.10.1
+
+## [0.4.11](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.10...trust-graph-v0.4.11) (2024-01-17)
+
+
+### Miscellaneous Chores
+
+* **trust-graph:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.10](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.9...trust-graph-v0.4.10) (2024-01-03)
+
+
+### Bug Fixes
+
+* **trust-graph:** Revert release 0.4.10 ([#153](https://github.com/fluencelabs/trust-graph/issues/153)) ([b263ce1](https://github.com/fluencelabs/trust-graph/commit/b263ce1fb13b937b629608ede35b6f436023dcac))
+
+## [0.4.9](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.8...trust-graph-v0.4.9) (2023-12-28)
+
+
+### Miscellaneous Chores
+
+* **trust-graph:** Synchronize trust-graph, wasm and api versions
+
+## [0.4.8](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.7...trust-graph-v0.4.8) (2023-12-20)
+
+
+### Features
+
+* update marine sdk's, configs and sqlite connector ([#129](https://github.com/fluencelabs/trust-graph/issues/129)) ([0b66f4e](https://github.com/fluencelabs/trust-graph/commit/0b66f4e0536633879de46f69ac8391c72ece7e77))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.10.3 to 0.10.4
+
+## [0.4.7](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.6...trust-graph-v0.4.7) (2023-07-04)
+
+
+### Miscellaneous Chores
+
+* **trust-graph:** Synchronize trust-graph, wasm and api versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.10.2 to 0.10.3
+
+## [0.4.6](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.5...trust-graph-v0.4.6) (2023-06-30)
+
+
+### Bug Fixes
+
+* **deps:** update rust crate derivative to 2.2.0 ([2001f90](https://github.com/fluencelabs/trust-graph/commit/2001f900fa13a949decd513d8cbe15e3f006a7fc))
+* **deps:** update rust crate derivative to 2.2.0 ([#88](https://github.com/fluencelabs/trust-graph/issues/88)) ([2001f90](https://github.com/fluencelabs/trust-graph/commit/2001f900fa13a949decd513d8cbe15e3f006a7fc))
+
+
+### Reverts
+
+* release master ([#110](https://github.com/fluencelabs/trust-graph/issues/110)) ([d80a43b](https://github.com/fluencelabs/trust-graph/commit/d80a43bcff721aff8fadf3d2d5c252804ce27a6c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * fluence-keypair bumped from 0.10.1 to 0.10.2
+
+## [0.4.5](https://github.com/fluencelabs/trust-graph/compare/trust-graph-v0.4.4...trust-graph-v0.4.5) (2023-05-09)
+
+
+### Features
+
+* dummy to trigger release ([#101](https://github.com/fluencelabs/trust-graph/issues/101)) ([1a26a68](https://github.com/fluencelabs/trust-graph/commit/1a26a6809ea9a90ca8ff3829a76257779a8767d5))
+
+## [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.11"
+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.4" }
+bs58 = "0.4.0"
+failure = "0.1.6"
+log = "0.4.11"
+ref-cast = "1.0.2"
+derivative = "2.2.0"
+thiserror = "1.0.23"
+sha2 = "0.10.6"
+nonempty = "0.8.1"
+rand = "0.8.5"

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

@@ -29,7 +29,7 @@ use std::{
 #[repr(transparent)]
 pub struct PublicKeyHashable(PublicKey);
 
-#[allow(clippy::derive_hash_xor_eq)]
+#[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for PublicKeyHashable {
     fn hash<H: Hasher>(&self, state: &mut H) {
         state.write(&self.0.encode());
@@ -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}")
     }
 }
 
@@ -154,7 +154,7 @@ where
         C: Borrow<Certificate>,
     {
         let chain = &cert.borrow().chain;
-        let mut issued_by = chain.get(0).ok_or(EmptyChain)?.issued_for.clone();
+        let mut issued_by = chain.first().ok_or(EmptyChain)?.issued_for.clone();
 
         // TODO: optimize to check only root weight
         for trust in chain {
@@ -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
             })