Skeleton

crypto/kzg/src/kzg_commitment.rs

@@ -0,0 +1,36 @@
+use derivative::Derivative;
+use serde_big_array::BigArray;
+use serde_derive::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use tree_hash::{PackedEncoding, TreeHash};
+
+#[derive(Derivative, Debug, Clone, Encode, Decode, Serialize, Deserialize)]
+#[derivative(PartialEq, Eq, Hash)]
+#[ssz(struct_behaviour = "transparent")]
+pub struct KzgCommitment(#[serde(with = "BigArray")] pub [u8; 48]);
+
+impl Display for KzgCommitment {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", eth2_serde_utils::hex::encode(self.0))
+    }
+}
+
+impl TreeHash for KzgCommitment {
+    fn tree_hash_type() -> tree_hash::TreeHashType {
+        <[u8; 48] as TreeHash>::tree_hash_type()
+    }
+
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        self.0.tree_hash_packed_encoding()
+    }
+
+    fn tree_hash_packing_factor() -> usize {
+        <[u8; 48] as TreeHash>::tree_hash_packing_factor()
+    }
+
+    fn tree_hash_root(&self) -> tree_hash::Hash256 {
+        self.0.tree_hash_root()
+    }
+}

crypto/kzg/src/kzg_proof.rs

@@ -0,0 +1,54 @@
+use serde::{Deserialize, Serialize};
+use serde_big_array::BigArray;
+use ssz_derive::{Decode, Encode};
+use std::fmt;
+use tree_hash::{PackedEncoding, TreeHash};
+
+const KZG_PROOF_BYTES_LEN: usize = 48;
+
+#[derive(Debug, PartialEq, Hash, Clone, Copy, Encode, Decode, Serialize, Deserialize)]
+#[serde(transparent)]
+#[ssz(struct_behaviour = "transparent")]
+pub struct KzgProof(#[serde(with = "BigArray")] pub [u8; KZG_PROOF_BYTES_LEN]);
+
+impl fmt::Display for KzgProof {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", eth2_serde_utils::hex::encode(self.0))
+    }
+}
+
+impl Default for KzgProof {
+    fn default() -> Self {
+        KzgProof([0; 48])
+    }
+}
+
+impl From<[u8; KZG_PROOF_BYTES_LEN]> for KzgProof {
+    fn from(bytes: [u8; KZG_PROOF_BYTES_LEN]) -> Self {
+        Self(bytes)
+    }
+}
+
+impl Into<[u8; KZG_PROOF_BYTES_LEN]> for KzgProof {
+    fn into(self) -> [u8; KZG_PROOF_BYTES_LEN] {
+        self.0
+    }
+}
+
+impl TreeHash for KzgProof {
+    fn tree_hash_type() -> tree_hash::TreeHashType {
+        <[u8; KZG_PROOF_BYTES_LEN]>::tree_hash_type()
+    }
+
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        self.0.tree_hash_packed_encoding()
+    }
+
+    fn tree_hash_packing_factor() -> usize {
+        <[u8; KZG_PROOF_BYTES_LEN]>::tree_hash_packing_factor()
+    }
+
+    fn tree_hash_root(&self) -> tree_hash::Hash256 {
+        self.0.tree_hash_root()
+    }
+}

crypto/kzg/src/lib.rs

@@ -0,0 +1,30 @@
+mod kzg_commitment;
+mod kzg_proof;
+
+use std::path::PathBuf;
+
+use c_kzg::{Error as CKzgError, KZGSettings};
+
+pub use crate::{kzg_commitment::KzgCommitment, kzg_proof::KzgProof};
+
+#[derive(Debug)]
+pub enum Error {
+    InvalidTrustedSetup(CKzgError),
+}
+
+pub struct Kzg {
+    _trusted_setup: KZGSettings,
+}
+
+impl Kzg {
+    pub fn new_from_file(file_path: PathBuf) -> Result<Self, Error> {
+        Ok(Self {
+            _trusted_setup: KZGSettings::load_trusted_setup(file_path)
+                .map_err(|e| Error::InvalidTrustedSetup(e))?,
+        })
+    }
+
+    pub fn verify_aggregate_kzg_proof() {}
+
+    pub fn blob_to_kzg_commitment() {}
+}