diff --git a/src/blob.rs b/src/blob.rs
index 8dd42cd..d91acfc 100644
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -70,7 +70,7 @@ impl<const N: usize> Blob<N> {
         const DOMAIN: &[u8; 16] = b"FSBLOBVERIFY_V1_";
         let degree = (N as u128).to_be_bytes();
 
-        let comm = commitment.0.serialize();
+        let comm = commitment.serialize();
 
         let mut data = Vec::with_capacity(8 + 16 + Commitment::BYTES + Self::BYTES);
         data.extend_from_slice(DOMAIN);
diff --git a/src/kzg/commitment.rs b/src/kzg/commitment.rs
deleted file mode 100644
index 6e06142..0000000
--- a/src/kzg/commitment.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use crate::bls::{Error as BlsError, P1};
-
-use super::Error;
-
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub struct Commitment(pub(crate) P1);
-
-impl Commitment {
-    pub const BYTES: usize = P1::BYTES;
-
-    pub fn deserialize<T: AsRef<[u8; Self::BYTES]>>(bytes: T) -> Result<Self, Error> {
-        P1::deserialize(bytes)
-            .map(Self)
-            .map_err(|err| Error::Bls(BlsError::from(err)))
-    }
-}
-
-impl From<P1> for Commitment {
-    fn from(point: P1) -> Self {
-        Self(point)
-    }
-}
diff --git a/src/kzg/mod.rs b/src/kzg/mod.rs
index 609b3eb..f66e94b 100644
--- a/src/kzg/mod.rs
+++ b/src/kzg/mod.rs
@@ -1,16 +1,15 @@
 use crate::bls;
 
-mod commitment;
 mod poly;
-mod proof;
 mod setup;
 
+pub type Proof = bls::P1;
+pub type Commitment = bls::P1;
+
 pub enum Error {
     Bls(bls::Error),
 }
 
 pub(crate) use poly::Polynomial;
 
-pub use commitment::Commitment;
-pub use proof::Proof;
 pub use setup::Setup;
diff --git a/src/kzg/poly.rs b/src/kzg/poly.rs
index 7b36d52..5fbf2c9 100644
--- a/src/kzg/poly.rs
+++ b/src/kzg/poly.rs
@@ -3,7 +3,7 @@ use crate::{
     math::BitReversalPermutation,
 };
 
-use super::{proof::Proof, setup::Setup};
+use super::{setup::Setup, Proof};
 
 #[derive(Clone, Debug)]
 pub(crate) struct Polynomial<'a, const N: usize>(pub(crate) &'a [Fr; N]);
@@ -71,6 +71,6 @@ impl<'a, const N: usize> Polynomial<'a, N> {
         let g1_lagrange = BitReversalPermutation::new(setup.g1_lagrange.as_slice());
         let lincomb = P1::lincomb(g1_lagrange.iter().zip(quotient_poly.iter()));
 
-        (eval, Proof(lincomb))
+        (eval, lincomb)
     }
 }
diff --git a/src/kzg/proof.rs b/src/kzg/proof.rs
deleted file mode 100644
index 73ca9cf..0000000
--- a/src/kzg/proof.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use crate::bls::{Error as BlsError, P1};
-
-use super::Error;
-
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub struct Proof(pub(crate) P1);
-
-impl Proof {
-    pub const BYTES: usize = P1::BYTES;
-
-    pub fn deserialize<T: AsRef<[u8; Self::BYTES]>>(bytes: T) -> Result<Self, Error> {
-        P1::deserialize(bytes)
-            .map(Self)
-            .map_err(|err| Error::Bls(BlsError::from(err)))
-    }
-}
-
-impl From<P1> for Proof {
-    fn from(point: P1) -> Self {
-        Self(point)
-    }
-}
diff --git a/src/kzg/setup.rs b/src/kzg/setup.rs
index 755e3f6..fb1b7e9 100644
--- a/src/kzg/setup.rs
+++ b/src/kzg/setup.rs
@@ -95,8 +95,8 @@ impl<const G1: usize, const G2: usize> Setup<G1, G2> {
         point: &Fr,
         eval: &Fr,
     ) -> bool {
-        let pairing1 = (proof.0, self.g2_monomial[1] + (P2::neg_generator() * point));
-        let pairing2 = (commitment.0 + (P1::neg_generator() * eval), P2::generator());
+        let pairing1 = (*proof, self.g2_monomial[1] + (P2::neg_generator() * point));
+        let pairing2 = (*commitment + (P1::neg_generator() * eval), P2::generator());
         bls::verify_pairings(pairing1, pairing2)
     }
 
@@ -126,15 +126,9 @@ impl<const G1: usize, const G2: usize> Setup<G1, G2> {
             rpowers.push(r.pow(&Fr::from(i as u64)));
         }
 
-        let proof_lincomb = P1::lincomb(
-            proofs
-                .as_ref()
-                .iter()
-                .map(|proof| &proof.0)
-                .zip(rpowers.iter()),
-        );
+        let proof_lincomb = P1::lincomb(proofs.as_ref().iter().zip(rpowers.iter()));
         let proof_z_lincomb = P1::lincomb_owned(
-            proofs.as_ref().iter().map(|proof| proof.0).zip(
+            proofs.as_ref().iter().copied().zip(
                 points
                     .as_ref()
                     .iter()
@@ -147,7 +141,7 @@ impl<const G1: usize, const G2: usize> Setup<G1, G2> {
             .as_ref()
             .iter()
             .zip(evals.as_ref().iter())
-            .map(|(comm, eval)| comm.0 + (P1::neg_generator() * eval));
+            .map(|(comm, eval)| *comm + (P1::neg_generator() * eval));
         let comm_minus_eval_lincomb = P1::lincomb_owned(comm_minus_eval.zip(rpowers));
 
         bls::verify_pairings(
@@ -492,7 +486,7 @@ mod tests {
                     let (_eval, proof) = poly.prove(input.z, &setup);
 
                     assert_eq!(eval, expected_eval);
-                    assert_eq!(proof.0, expected_proof);
+                    assert_eq!(proof, expected_proof);
                 }
                 Err(_) => {
                     assert!(case.output.is_none());