feat(ethexe): Support Shielded transactions

Cargo.toml

@@ -248,12 +248,12 @@ which = "4.4.2"
 winapi = "0.3.9"
 paste = "1.0"
 tempfile = "3.19"
-ark-std = { version = "0.4.0", default-features = false }
-ark-bls12-381 = { version = "0.4.0", default-features = false }
-ark-serialize = { version = "0.4", default-features = false }
-ark-ec = { version = "0.4.2", default-features = false }
-ark-ff = { version = "0.4.2", default-features = false }
-ark-scale = { version = "0.0.12", default-features = false }
+ark-std = { version = "0.5", default-features = false }
+ark-bls12-381 = { version = "0.5", default-features = false }
+ark-serialize = { version = "0.5", default-features = false }
+ark-ec = { version = "0.5", default-features = false }
+ark-ff = { version = "0.5", default-features = false }
+ark-scale = { version = "0.0.13", default-features = false }
 sha2 = { version = "0.10.8", default-features = false }
 sha3 = { version = "0.10.8", default-features = false }
 arrayvec = { version = "0.7.4", default-features = false }
@@ -277,8 +277,7 @@ metrics = "0.24.0"
 metrics-derive = "0.1"
 metrics-exporter-prometheus = { version = "0.16.0", default-features = false }
 
-gear-tdec = { package = "ferveo-gear-tdec", version = "0.5.0"}
-
+gear-tdec = { package = "ferveo-gear-tdec", version = "0.8.0", default-features = false}
 # Published deps
 #
 # https://github.com/gear-tech/gear-dlmalloc/tree/0.2.1

ethexe/cli/Cargo.toml

@@ -36,6 +36,7 @@ ethexe-processor.workspace = true
 ethexe-runtime-common.workspace = true
 ethexe-db.workspace = true
 gprimitives = { workspace = true, features = ["std"] }
+gear-tdec.workspace = true
 
 anyhow.workspace = true
 alloy-chains.workspace = true

ethexe/cli/src/params/mod.rs

@@ -19,13 +19,15 @@ mod network;
 mod node;
 mod prometheus;
 mod rpc;
+mod tdec;
 
 pub use ethereum::EthereumParams;
 pub use malachite::MalachiteParams;
 pub use network::NetworkParams;
 pub use node::NodeParams;
 pub use prometheus::PrometheusParams;
 pub use rpc::RpcParams;
+pub use tdec::TdecParams;
 
 /// CLI/TOML-config parameters for the ethexe service.
 #[derive(Clone, Debug, Default, Deserialize, Parser)]
@@ -57,6 +59,9 @@ pub struct Params {
     /// Prometheus (metrics) service parameters.
     #[clap(flatten)]
     pub prometheus: Option<PrometheusParams>,
+
+    #[clap(flatten)]
+    pub tdec: Option<TdecParams>,
 }
 
 impl Params {
@@ -81,6 +86,7 @@ impl Params {
             malachite,
             rpc,
             prometheus,
+            tdec,
         } = self;
 
         let node = node.context("missing node params")?;
@@ -97,13 +103,15 @@ impl Params {
         let malachite = malachite.unwrap_or_default().into_config()?;
         let rpc = rpc.and_then(|p| p.into_config(&node));
         let prometheus = prometheus.and_then(|p| p.into_config());
+        let tdec = tdec.map(|p| p.into_config());
         Ok(Config {
             node,
             ethereum,
             network,
             malachite,
             rpc,
             prometheus,
+            tdec,
         })
     }
 }
@@ -117,6 +125,7 @@ impl MergeParams for Params {
             malachite: MergeParams::optional_merge(self.malachite, with.malachite),
             rpc: MergeParams::optional_merge(self.rpc, with.rpc),
             prometheus: MergeParams::optional_merge(self.prometheus, with.prometheus),
+            tdec: MergeParams::optional_merge(self.tdec, with.tdec),
         }
     }
 }

ethexe/cli/src/params/tdec.rs

@@ -0,0 +1,179 @@
+// Copyright (C) Gear Technologies Inc.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+use crate::params::MergeParams;
+use ethexe_service::config::ThresholdDecryptionCliConfig;
+use gear_tdec::bls12_381::{
+    DkgPublicKey, PublicDecryptionContextSimple as PublicDecryptionContext,
+};
+use gsigner::Address;
+
+/// Threshold-decryption parameters.
+#[derive(Clone, Debug, serde::Deserialize, clap::Parser)]
+pub struct TdecParams {
+    /// Minimal number of validator decryption shares required to decrypt a
+    /// shielded transaction.
+    #[arg(long)]
+    pub threshold: std::num::NonZeroUsize,
+
+    /// DKG public key used by clients to encrypt shielded transaction fields.
+    #[arg(long = "dkg-public-key", alias = "pubic-key")]
+    #[serde(rename = "dkg-public-key")]
+    pub dkg_public_key: DkgPublicKey,
+
+    /// Public decryption contexts for validators participating in threshold
+    /// decryption.
+    ///
+    /// Pass one option per validator as `ADDRESS=CONTEXT`, where `ADDRESS` is
+    /// a secp256k1 validator address and `CONTEXT` is the hex string produced
+    /// by `PublicDecryptionContextSimple`.
+    #[arg(long = "validators-contexts", value_name = "ADDRESS=CONTEXT")]
+    #[serde(rename = "validators-contexts")]
+    pub validators_contexts: Option<Vec<ValidatorContext>>,
+}
+
+impl TdecParams {
+    pub fn into_config(self) -> ThresholdDecryptionCliConfig {
+        ThresholdDecryptionCliConfig {
+            threshold: self.threshold,
+            dkg_public_key: self.dkg_public_key,
+            validators_contexts: self
+                .validators_contexts
+                .map(|ctxs| ctxs.into_iter().map(ValidatorContext::into_parts).collect()),
+        }
+    }
+}
+
+impl MergeParams for TdecParams {
+    fn merge(self, with: Self) -> Self {
+        let validators_contexts = match with.validators_contexts {
+            Some(mut contexts) => {
+                if let Some(my_contexts) = self.validators_contexts {
+                    contexts.extend(my_contexts);
+                }
+                Some(contexts)
+            }
+            None => self.validators_contexts,
+        };
+        Self {
+            threshold: self.threshold,
+            dkg_public_key: self.dkg_public_key,
+            validators_contexts,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ValidatorContext {
+    pub address: Address,
+    pub context: PublicDecryptionContext,
+}
+
+impl ValidatorContext {
+    fn into_parts(self) -> (Address, PublicDecryptionContext) {
+        (self.address, self.context)
+    }
+}
+
+impl From<(Address, PublicDecryptionContext)> for ValidatorContext {
+    fn from((address, context): (Address, PublicDecryptionContext)) -> Self {
+        Self { address, context }
+    }
+}
+
+impl std::str::FromStr for ValidatorContext {
+    type Err = anyhow::Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let (address, context) = value.split_once('=').ok_or_else(|| {
+            anyhow::anyhow!("expected validator context in ADDRESS=CONTEXT format")
+        })?;
+
+        Ok(Self {
+            address: address.parse()?,
+            context: context.parse()?,
+        })
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for ValidatorContext {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(serde::Deserialize)]
+        #[serde(untagged)]
+        enum ValidatorContextRepr {
+            Named {
+                address: Address,
+                context: PublicDecryptionContext,
+            },
+            Tuple((Address, PublicDecryptionContext)),
+        }
+
+        match ValidatorContextRepr::deserialize(deserializer)? {
+            ValidatorContextRepr::Named { address, context } => Ok(Self { address, context }),
+            ValidatorContextRepr::Tuple(tuple) => Ok(tuple.into()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    fn public_decryption_context(
+        dealer: &gear_tdec::DealerOutput<gear_tdec::bls12_381::E>,
+    ) -> PublicDecryptionContext {
+        dealer.private_contexts[0].public_decryption_contexts[0].clone()
+    }
+
+    #[test]
+    fn validator_context_parses_from_cli_value() {
+        let dealer = gear_tdec::deal::<gear_tdec::bls12_381::E>(
+            1,
+            1,
+            &mut gear_tdec::rand_utils::test_rng(),
+        );
+        let address = Address::from([1; 20]);
+        let context = public_decryption_context(&dealer);
+
+        let parsed = format!("{address}={context}")
+            .parse::<ValidatorContext>()
+            .expect("validator context must parse");
+
+        assert_eq!(parsed.address, address);
+        assert_eq!(parsed.context.to_string(), context.to_string());
+    }
+
+    #[test]
+    fn tdec_params_accepts_validator_contexts_from_clap() {
+        let dealer = gear_tdec::deal::<gear_tdec::bls12_381::E>(
+            1,
+            1,
+            &mut gear_tdec::rand_utils::test_rng(),
+        );
+        let address = Address::from([1; 20]);
+        let context = public_decryption_context(&dealer);
+        let context_arg = format!("{address}={context}");
+
+        let params = TdecParams::try_parse_from([
+            "ethexe",
+            "--threshold",
+            "1",
+            "--dkg-public-key",
+            &dealer.public_key.to_string(),
+            "--validators-contexts",
+            &context_arg,
+        ])
+        .expect("tdec params must parse");
+
+        let contexts = params
+            .validators_contexts
+            .expect("validator contexts must be present");
+        assert_eq!(contexts.len(), 1);
+        assert_eq!(contexts[0].address, address);
+        assert_eq!(contexts[0].context.to_string(), context.to_string());
+    }
+}

ethexe/common/Cargo.toml

@@ -15,24 +15,30 @@
 [dependencies]
 alloy-primitives = { workspace = true, features = ["serde"] }
 gear-core.workspace = true
 sp-core.workspace = true
 gprimitives.workspace = true
 parity-scale-codec.workspace = true
 scale-info = { workspace = true, features = ["derive"] }
 hex.workspace = true
-serde = { workspace = true, optional = true }
 derive_more.workspace = true
 anyhow.workspace = true
 auto_impl.workspace = true
 gsigner = { workspace = true, default-features = false, features = [
     "secp256k1",
     "codec",
     "serde",
+    "tdec",
 ] }
 sha3.workspace = true
 k256 = { version = "0.13.4", features = ["ecdsa"], default-features = false }
 nonempty.workspace = true
-gear-tdec = { workspace = true, optional = true }
+
+ark-ec.workspace = true
+
+# optional dependencies
+serde = { workspace = true, optional = true }
+gear-tdec = { workspace = true, features = ["serde-hex", "parity-codec", "bls12_381"]}
+ark-serialize = { workspace = true }
 
 # mock deps
 itertools = { workspace = true, optional = true }
@@ -59,7 +65,5 @@
     "alloy-primitives/std",
     "gsigner/std",
     "gsigner/keyring",
-    "shielded"
 ]
-shielded = ["dep:gear-tdec"]
 mock = ["std", "itertools/use_std", "tap", "proptest"]