blst lagrange interpolation

Cargo.toml

@@ -3,6 +3,7 @@
 members = [
     "anchor",
     "anchor/client",
+    "anchor/common/bls_lagrange",
     "anchor/common/qbft",
     "anchor/common/ssv_types",
     "anchor/common/version",
@@ -24,6 +25,7 @@ edition = "2021"
 # This table has three subsections: first the internal dependencies, then the lighthouse dependencies, then all other.
 [workspace.dependencies]
 anchor_validator_store = { path = "anchor/validator_store" }
+bls_lagrange = { path = "anchor/common/bls_lagrange" }
 client = { path = "anchor/client" }
 database = { path = "anchor/database" }
 eth = { path = "anchor/eth" }
@@ -71,6 +73,9 @@ alloy = { version = "0.6.4", features = [
 async-channel = "1.9"
 axum = "0.7.7"
 base64 = "0.22.1"
+blst = { git = "https://github.com/dknopik/blst", branch = "sk-conversion" }
+# the custom repo is needed because they fix to a specific version of blst, which conflicts with the line above
+blstrs_plus = { git = "https://github.com/dknopik/blstrs", branch = "pls" }
 clap = { version = "4.5.15", features = ["derive", "wrap_help"] }
 dashmap = "6.1.0"
 derive_more = { version = "1.0.0", features = ["full"] }
@@ -83,6 +88,7 @@ indexmap = "2.7.0"
 num_cpus = "1"
 openssl = "0.10.68"
 parking_lot = "0.12"
+rand = "0.8.5"
 reqwest = "0.12.12"
 rusqlite = "0.28.0"
 serde = { version = "1.0.208", features = ["derive"] }
@@ -99,8 +105,13 @@ tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["fmt", "env-filter"] }
 tree_hash = "0.8"
 tree_hash_derive = "0.8"
+vsss-rs = "5.1.0"
 zeroize = "1.8.1"
 
+[patch.crates-io]
+# todo: remove when https://github.com/supranational/blst/pull/248 is merged
+blst = { git = "https://github.com/dknopik/blst", branch = "sk-conversion" }
+
 [profile.maxperf]
 inherits = "release"
 

anchor/common/bls_lagrange/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "bls_lagrange"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bls = { workspace = true }
+blst = { workspace = true, optional = true }
+blstrs_plus = { workspace = true, optional = true }
+rand = { workspace = true }
+vsss-rs = { workspace = true, optional = true }
+zeroize = { workspace = true }
+
+[dev-dependencies]
+blst = { workspace = true }
+
+[features]
+default = ["blsful"]
+blsful = ["dep:blstrs_plus", "dep:vsss-rs"]
+blst = ["dep:blst"]
+blst_single_thread = ["blst"]

anchor/common/bls_lagrange/src/blsful.rs

@@ -0,0 +1,126 @@
+use crate::Error;
+use blstrs_plus::{G2Projective, Scalar};
+use rand::{CryptoRng, Rng};
+use std::num::NonZeroU64;
+use vsss_rs::{
+    shamir, IdentifierPrimeField, ParticipantIdGeneratorType, ReadableShareSet, ValueGroup,
+};
+use zeroize::Zeroizing;
+
+#[derive(Debug, Clone)]
+pub struct KeyId {
+    num: u64,
+    identifier: IdentifierPrimeField<Scalar>,
+}
+
+impl TryFrom<u64> for KeyId {
+    type Error = Error;
+
+    fn try_from(value: u64) -> Result<Self, Error> {
+        if value != 0 {
+            Ok(KeyId {
+                num: value,
+                identifier: IdentifierPrimeField(Scalar::from(value)),
+            })
+        } else {
+            Err(Error::ZeroId)
+        }
+    }
+}
+impl From<NonZeroU64> for KeyId {
+    fn from(value: NonZeroU64) -> Self {
+        KeyId {
+            num: value.get(),
+            identifier: IdentifierPrimeField(Scalar::from(value.get())),
+        }
+    }
+}
+
+impl From<KeyId> for u64 {
+    fn from(value: KeyId) -> Self {
+        value.num
+    }
+}
+
+pub fn split_with_rng(
+    key: bls::SecretKey,
+    threshold: u64,
+    ids: impl IntoIterator<Item = KeyId>,
+    rng: &mut (impl CryptoRng + Rng),
+) -> Result<Vec<(KeyId, bls::SecretKey)>, Error> {
+    let result = Scalar::from_be_bytes(
+        key.serialize()
+            .as_bytes()
+            .try_into()
+            .map_err(|_| Error::InternalError)?,
+    );
+    let key = if result.is_some().into() {
+        IdentifierPrimeField(result.unwrap())
+    } else {
+        return Err(Error::InternalError);
+    };
+
+    let ids = ids.into_iter().map(|k| k.identifier).collect::<Vec<_>>();
+
+    let result = Zeroizing::new(
+        shamir::split_secret_with_participant_generator(
+            threshold as usize,
+            ids.len(),
+            &key,
+            rng,
+            &[ParticipantIdGeneratorType::List { list: &ids }],
+        )
+        .map_err(|_| Error::InternalError)?,
+    );
+
+    result
+        .iter()
+        .map(|(identifier, share)| {
+            bls::SecretKey::deserialize(&share.0.to_be_bytes())
+                .map_err(|_| Error::InternalError)
+                .map(move |sk| {
+                    let bytes = identifier.0.to_be_bytes();
+                    debug_assert_eq!(bytes[..24], [0; 24]);
+                    (
+                        KeyId {
+                            num: u64::from_be_bytes((&bytes[24..]).try_into().unwrap()),
+                            identifier: *identifier,
+                        },
+                        sk,
+                    )
+                })
+        })
+        .collect()
+}
+
+pub fn combine_signatures(
+    signatures: &[bls::Signature],
+    ids: &[KeyId],
+) -> Result<bls::Signature, Error> {
+    if signatures.len() < 2 {
+        return Err(Error::LessThanTwoSignatures);
+    }
+    if signatures.len() != ids.len() {
+        return Err(Error::NotOneIdPerSignature);
+    }
+
+    let share_set = signatures
+        .iter()
+        .zip(ids)
+        .map(|(sig, id)| {
+            let Some(bytes) = sig.serialize_uncompressed() else {
+                return Err(Error::InternalError);
+            };
+            let g2 = G2Projective::from_uncompressed(&bytes);
+            if g2.is_some().into() {
+                Ok((id.identifier, ValueGroup(g2.unwrap())))
+            } else {
+                Err(Error::InternalError)
+            }
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let result = share_set.combine().map_err(|_| Error::InternalError)?;
+    bls::Signature::deserialize_uncompressed(&result.0.to_uncompressed())
+        .map_err(|_| Error::InternalError)
+}