chore: release master (#113)

Revert "chore: release master (#111)"

This reverts commit 3a5f23741f.

.github/release-please/config.json

@@ -14,7 +14,8 @@
       "components": [
         "trust-graph",
         "trust-graph-api",
-        "trust-graph-wasm"
+        "trust-graph-wasm",
+        "distro"
       ]
     }
   ],
@@ -31,6 +32,9 @@
     },
     "keypair": {
       "component": "keypair"
+    },
+    "distro": {
+      "component": "distro"
     }
   }
 }

.github/release-please/manifest.json

@@ -1,6 +1,7 @@
 {
-  "trust-graph": "0.4.5",
+  "trust-graph": "0.4.6",
-  "aqua": "0.4.5",
+  "aqua": "0.4.6",
-  "service": "0.4.5",
+  "service": "0.4.6",
-  "keypair": "0.10.1"
+  "keypair": "0.10.2",
+  "distro": "0.4.6"
 }

.github/workflows/release.yml

@@ -71,7 +71,6 @@ jobs:
 
       - name: Build
         run: ./build.sh
-        working-directory: service
 
       - name: Install cargo-workspaces
         uses: baptiste0928/cargo-install@v1.3.0

.github/workflows/tests.yml

@@ -23,7 +23,6 @@ jobs:
         uses: fluencelabs/setup-marine@v1
 
       - name: Build
-        working-directory: ./service
         run: ./build.sh
 
       - name: Run cargo clippy
@@ -42,7 +41,8 @@ jobs:
         env:
           NEXTEST_RETRIES: 10
           NEXTEST_TEST_THREADS: 10
-        run: cargo nextest run --release --all-features --no-fail-fast
+        # 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

.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

@@ -2,8 +2,9 @@
 members = [
     "trust-graph",
     "keypair",
-    "service"
+    "service",
+    "distro"
 ]
 
 [workspace.dependencies]
-libp2p-identity = { version = "0.1.0", default-features = false, features = ["peerid", "rsa", "ed25519", "secp256k1", "multihash"] }
+libp2p-identity = { version = "0.2.1", default-features = false }

aqua/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [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)
 
 

aqua/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@fluencelabs/trust-graph",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@fluencelabs/trust-graph",
-      "version": "0.4.5",
+      "version": "0.4.6",
       "license": "MIT",
       "dependencies": {
         "@fluencelabs/aqua-lib": "^0.7.0"

aqua/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluencelabs/trust-graph",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Aqua Trust Graph API library",
   "files": [
     "*.aqua"

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

distro/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [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.6"
+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 keys and 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.5.2"

distro/Config.toml

@@ -0,0 +1,14 @@
+modules_dir = "."
+
+[[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();
+}

keypair/CHANGELOG.md

@@ -4,6 +4,23 @@ 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.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)
 
 

keypair/Cargo.toml

@@ -1,15 +1,15 @@
 [package]
 name = "fluence-keypair"
-version = "0.10.1"
+version = "0.10.2"
 authors = ["Fluence Labs"]
 edition = "2021"
-description = "identity"
+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"] }
-bs58 = "0.4.0"
+bs58 = "0.5.0"
 ed25519-dalek = { version = "1.0.1", features = ["serde", "std"] }
 rand = "0.8.5"
 thiserror = "1.0.23"
@@ -20,7 +20,7 @@ sha2 = "0.10.6"
 zeroize = "1"
 serde_bytes = "0.11"
 eyre = "0.6.5"
-libp2p-identity = { workspace = true, default-features = false, features = ["peerid", "rsa", "ed25519", "secp256k1", "multihash"] }
+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]

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_identity::PeerId;
+use libp2p_identity::{KeyType, Keypair, PeerId};
 use std::convert::TryFrom;
 use std::str::FromStr;
 
@@ -47,7 +47,6 @@ use std::str::FromStr;
 /// let keypair = Keypair::rsa_from_pkcs8(&mut bytes);
 /// ```
 ///
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyFormat {
     Ed25519,
@@ -106,6 +105,7 @@ impl From<KeyFormat> for String {
         }
     }
 }
+
 #[derive(Clone)]
 pub enum KeyPair {
     /// An Ed25519 keypair.
@@ -250,42 +250,61 @@ impl KeyPair {
 
 impl From<libp2p_identity::Keypair> for KeyPair {
     fn from(key: libp2p_identity::Keypair) -> Self {
-        use libp2p_identity::Keypair::*;
+        fn convert_keypair(key: Keypair) -> eyre::Result<KeyPair> {
-
+            match key.key_type() {
-        #[allow(deprecated)] //TODO: fix it later
+                KeyType::Ed25519 => {
-        match key {
+                    let kp = key.try_into_ed25519()?;
-            Ed25519(kp) => KeyPair::Ed25519(ed25519::Keypair::decode(&mut kp.encode()).unwrap()),
+                    let raw_kp = ed25519::Keypair::decode(&mut kp.to_bytes())?;
-            #[cfg(not(target_arch = "wasm32"))]
+                    Ok(KeyPair::Ed25519(raw_kp))
-            // safety: these Keypair structures are identical
+                }
-            Rsa(kp) => KeyPair::Rsa(unsafe {
+                #[cfg(not(target_arch = "wasm32"))]
-                std::mem::transmute::<libp2p_identity::rsa::Keypair, rsa::Keypair>(kp)
+                KeyType::RSA => {
-            }),
+                    let kp = key.try_into_rsa()?;
-            Secp256k1(kp) => KeyPair::Secp256k1(secp256k1::Keypair::from(
+                    let raw_kp = unsafe {
-                secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
+                        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_identity::Keypair {
     fn from(key: KeyPair) -> Self {
-        use libp2p_identity::Keypair;
+        fn convert_keypair(key: KeyPair) -> eyre::Result<libp2p_identity::Keypair> {
-        use KeyPair::*;
+            match key {
-
+                KeyPair::Ed25519(kp) => {
-        #[allow(deprecated)] //TODO: fix it later
+                    let kp = Keypair::ed25519_from_bytes(kp.encode().to_vec().as_mut_slice())?;
-        match key {
+                    Ok(kp)
-            Ed25519(kp) => Keypair::Ed25519(
+                }
-                libp2p_identity::ed25519::Keypair::decode(kp.encode().to_vec().as_mut_slice())
+                #[cfg(not(target_arch = "wasm32"))]
-                    .unwrap(),
+                // safety: these Keypair structures are identical
-            ),
+                KeyPair::Rsa(kp) => {
-            #[cfg(not(target_arch = "wasm32"))]
+                    let kp = unsafe {
-            // safety: these Keypair structures are identical
+                        std::mem::transmute::<rsa::Keypair, libp2p_identity::rsa::Keypair>(kp)
-            Rsa(kp) => Keypair::Rsa(unsafe {
+                    };
-                std::mem::transmute::<rsa::Keypair, libp2p_identity::rsa::Keypair>(kp)
+                    let kp = Keypair::from(kp);
-            }),
+                    Ok(kp)
-            Secp256k1(kp) => Keypair::Secp256k1(libp2p_identity::secp256k1::Keypair::from(
+                }
-                libp2p_identity::secp256k1::SecretKey::from_bytes(kp.secret().to_bytes()).unwrap(),
+                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/public_key.rs

@@ -21,7 +21,7 @@ use crate::secp256k1;
 use crate::signature::Signature;
 
 use crate::key_pair::KeyFormat;
-use libp2p_identity::PeerId;
+use libp2p_identity::{KeyType, PeerId};
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
@@ -126,37 +126,58 @@ impl PublicKey {
 
 impl From<libp2p_identity::PublicKey> for PublicKey {
     fn from(key: libp2p_identity::PublicKey) -> Self {
-        use libp2p_identity::PublicKey::*;
+        fn convert_key(key: libp2p_identity::PublicKey) -> eyre::Result<PublicKey> {
-
+            match key.key_type() {
-        #[allow(deprecated)] //TODO: fix it later
+                KeyType::Ed25519 => {
-        match key {
+                    let pk = key.try_into_ed25519()?;
-            Ed25519(key) => {
+                    let raw_pk = ed25519::PublicKey::decode(&pk.to_bytes())?;
-                PublicKey::Ed25519(ed25519::PublicKey::decode(&key.encode()[..]).unwrap())
+                    Ok(PublicKey::Ed25519(raw_pk))
-            }
+                }
-            #[cfg(not(target_arch = "wasm32"))]
+                #[cfg(not(target_arch = "wasm32"))]
-            Rsa(key) => PublicKey::Rsa(rsa::PublicKey::from_pkcs1(key.encode_pkcs1()).unwrap()),
+                KeyType::RSA => {
-            Secp256k1(key) => {
+                    let pk = key.try_into_rsa()?;
-                PublicKey::Secp256k1(secp256k1::PublicKey::decode(&key.encode()[..]).unwrap())
+                    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_identity::PublicKey {
     fn from(key: PublicKey) -> Self {
-        #[allow(deprecated)] //TODO: fix it later
+        fn convert_key(key: PublicKey) -> eyre::Result<libp2p_identity::PublicKey> {
-        match key {
+            match key {
-            PublicKey::Ed25519(key) => libp2p_identity::PublicKey::Ed25519(
+                PublicKey::Ed25519(key) => {
-                libp2p_identity::ed25519::PublicKey::decode(&key.encode()[..]).unwrap(),
+                    let raw_pk =
-            ),
+                        libp2p_identity::ed25519::PublicKey::try_from_bytes(&key.encode())?;
-            #[cfg(not(target_arch = "wasm32"))]
+                    let pk = libp2p_identity::PublicKey::from(raw_pk);
-            PublicKey::Rsa(key) => libp2p_identity::PublicKey::Rsa(
+                    Ok(pk)
-                libp2p_identity::rsa::PublicKey::decode_x509(&key.encode_x509()).unwrap(),
+                }
-            ),
+                #[cfg(not(target_arch = "wasm32"))]
-            PublicKey::Secp256k1(key) => libp2p_identity::PublicKey::Secp256k1(
+                PublicKey::Rsa(key) => {
-                libp2p_identity::secp256k1::PublicKey::decode(&key.encode()[..]).unwrap(),
+                    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")
     }
 }
 
@@ -176,7 +197,7 @@ fn as_public_key(peer_id: &PeerId) -> Option<libp2p_identity::PublicKey> {
 
     match multihash::Code::try_from(mhash.code()) {
         Ok(multihash::Code::Identity) => {
-            libp2p_identity::PublicKey::from_protobuf_encoding(mhash.digest()).ok()
+            libp2p_identity::PublicKey::try_decode_protobuf(mhash.digest()).ok()
         }
         _ => None,
     }

keypair/src/secp256k1.rs

@@ -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() -> _);
+    }
 }

service/CHANGELOG.md

@@ -9,6 +9,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     * trust-graph bumped from 0.4.1 to 0.4.2
     * fluence-keypair bumped from 0.10.0 to 0.10.1
 
+## [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)
 
 

service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trust-graph-wasm"
-version = "0.4.5"
+version = "0.4.6"
 authors = ["Fluence Labs"]
 edition = "2021"
 description = "trust graph wasm"
@@ -12,8 +12,8 @@ name = "trust-graph"
 path = "src/main.rs"
 
 [dependencies]
-trust-graph = { version = "0.4.5", path = "../trust-graph" }
+trust-graph = { version = "0.4.6", path = "../trust-graph" }
-fluence-keypair = { version = "0.10.1", path = "../keypair" }
+fluence-keypair = { version = "0.10.2", path = "../keypair" }
 marine-rs-sdk = { version = "0.7.1", features = ["logger"] }
 marine-sqlite-connector = "0.8.0"
 

trust-graph/CHANGELOG.md

@@ -4,6 +4,26 @@
   * dependencies
     * fluence-keypair bumped from 0.10.0 to 0.10.1
 
+## [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)
 
 

trust-graph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trust-graph"
-version = "0.4.5"
+version = "0.4.6"
 authors = ["Fluence Labs"]
 edition = "2021"
 description = "trust graph"
@@ -10,12 +10,12 @@ repository = "https://github.com/fluencelabs/trust-graph"
 [dependencies]
 serde = { version = "1.0.118", features = ["derive"] }
 
-fluence-keypair = { path = "../keypair", version = "0.10.1" }
+fluence-keypair = { path = "../keypair", version = "0.10.2" }
 bs58 = "0.4.0"
 failure = "0.1.6"
 log = "0.4.11"
 ref-cast = "1.0.2"
-derivative = "2.1.1"
+derivative = "2.2.0"
 thiserror = "1.0.23"
 sha2 = "0.10.6"
 nonempty = "0.8.1"