diff --git a/src/share/additive.rs b/src/share/additive.rs
index 3092f606..0f30d244 100644
--- a/src/share/additive.rs
+++ b/src/share/additive.rs
@@ -15,7 +15,7 @@ use derivative::Derivative;
 
 use crate::reveal::Reveal;
 
-use super::pairing::ExtendedPairingEngine;
+// use super::pairing::ExtendedPairingEngine;
 // use super::group::GroupAffineShare;
 use super::{
     field::{ExtFieldShare, FieldShare},
@@ -193,7 +193,9 @@ macro_rules! impl_group_basics {
 
 impl_group_basics!(AdditiveGroupShare, Group);
 
-impl<G: Group> GroupShare<G> for AdditiveGroupShare<G> {}
+impl<G: Group> GroupShare<G> for AdditiveGroupShare<G> {
+    type FieldShare = AdditiveFieldShare<G::ScalarField>;
+}
 
 #[derive(Clone, Copy, Debug, Derivative)]
 #[derivative(
@@ -202,14 +204,14 @@ impl<G: Group> GroupShare<G> for AdditiveGroupShare<G> {}
 )]
 pub struct AdditivePairingShare<E: PairingEngine>(pub PhantomData<E>);
 
-impl<E: ExtendedPairingEngine> PairingShare<E> for AdditivePairingShare<E> {
+impl<E: PairingEngine> PairingShare<E> for AdditivePairingShare<E> {
     type FrShare = AdditiveFieldShare<E::Fr>;
     type FqShare = AdditiveFieldShare<E::Fq>;
     type FqeShare = AdditiveExtFieldShare<E::Fqe>;
     // Not a typo. We want a multiplicative subgroup.
     type FqkShare = MulExtFieldShare<E::Fqk>;
-    type G1AffineShare = AdditiveGroupShare<E::GroupedG1Affine>;
-    type G2AffineShare = AdditiveGroupShare<E::GroupedG2Affine>;
-    type G1ProjectiveShare = AdditiveGroupShare<E::GroupedG1Projective>;
-    type G2ProjectiveShare = AdditiveGroupShare<E::GroupedG2Projective>;
+    type G1AffineShare = AdditiveGroupShare<E::G1Affine>;
+    type G2AffineShare = AdditiveGroupShare<E::G2Affine>;
+    type G1ProjectiveShare = AdditiveGroupShare<E::G1Projective>;
+    type G2ProjectiveShare = AdditiveGroupShare<E::G2Projective>;
 }
diff --git a/src/share/group.rs b/src/share/group.rs
index 030c079f..bda0f0e3 100644
--- a/src/share/group.rs
+++ b/src/share/group.rs
@@ -8,6 +8,8 @@ use ark_serialize::{
 use std::fmt::Debug;
 use std::hash::Hash;
 
+use super::field::FieldShare;
+
 pub trait GroupShare<G: Group>:
     Clone
     + Copy
@@ -24,6 +26,7 @@ pub trait GroupShare<G: Group>:
     + ToBytes
     + 'static
 {
+    type FieldShare: FieldShare<G::ScalarField>;
 }
 
 // pub trait GroupAffineShare<G: AffineCurve>:
diff --git a/src/share/pairing.rs b/src/share/pairing.rs
index 2c4d58b2..939a01f6 100644
--- a/src/share/pairing.rs
+++ b/src/share/pairing.rs
@@ -1,4 +1,4 @@
-use ark_ec::{group::Group, AffineCurve, PairingEngine, ProjectiveCurve};
+use ark_ec::{bls12::Bls12Parameters, group::Group, AffineCurve, PairingEngine, ProjectiveCurve};
 
 use super::{
     field::{ExtFieldShare, FieldShare},
@@ -7,47 +7,53 @@ use super::{
 
 use std::{fmt::Debug, ops::MulAssign};
 
-pub trait ExtendedPairingEngine: PairingEngine {
-    type GroupedG1Projective: ProjectiveCurve<
-            BaseField = Self::Fq,
-            ScalarField = Self::Fr,
-            Affine = Self::GroupedG1Affine,
-        > + From<Self::GroupedG1Affine>
-        + Into<Self::GroupedG1Affine>
-        + MulAssign<Self::Fr>
-        // needed due to https://github.com/rust-lang/rust/issues/69640
-        + Group<ScalarField = Self::Fr>;
+// pub trait ExtendedPairingEngine: PairingEngine {
+//     type GroupedG1Projective: ProjectiveCurve<
+//             BaseField = Self::Fq,
+//             ScalarField = Self::Fr,
+//             Affine = Self::GroupedG1Affine,
+//         > + From<Self::GroupedG1Affine>
+//         + Into<Self::GroupedG1Affine>
+//         + MulAssign<Self::Fr>
+//         // needed due to https://github.com/rust-lang/rust/issues/69640
+//         + Group<ScalarField = Self::Fr>;
 
-    type GroupedG1Affine: AffineCurve<
-            BaseField = Self::Fq,
-            ScalarField = Self::Fr,
-            Projective = Self::GroupedG1Projective,
-        > + From<Self::GroupedG1Projective>
-        + Into<Self::GroupedG1Projective>
-        + Into<Self::G1Prepared>
-        + Group<ScalarField = Self::Fr>;
+//     type GroupedG1Affine: AffineCurve<
+//             BaseField = Self::Fq,
+//             ScalarField = Self::Fr,
+//             Projective = Self::GroupedG1Projective,
+//         > + From<Self::GroupedG1Projective>
+//         + Into<Self::GroupedG1Projective>
+//         + Into<Self::G1Prepared>
+//         + Group<ScalarField = Self::Fr>;
 
-    type GroupedG2Projective: ProjectiveCurve<
-            BaseField = Self::Fqe,
-            ScalarField = Self::Fr,
-            Affine = Self::GroupedG2Affine,
-        > + From<Self::GroupedG2Affine>
-        + Into<Self::GroupedG2Affine>
-        + MulAssign<Self::Fr>
-        // needed due to https://github.com/rust-lang/rust/issues/69640
-        + Group<ScalarField = Self::Fr>;
+//     type GroupedG2Projective: ProjectiveCurve<
+//             BaseField = Self::Fqe,
+//             ScalarField = Self::Fr,
+//             Affine = Self::GroupedG2Affine,
+//         > + From<Self::GroupedG2Affine>
+//         + Into<Self::GroupedG2Affine>
+//         + MulAssign<Self::Fr>
+//         // needed due to https://github.com/rust-lang/rust/issues/69640
+//         + Group<ScalarField = Self::Fr>;
 
-    type GroupedG2Affine: AffineCurve<
-            BaseField = Self::Fqe,
-            ScalarField = Self::Fr,
-            Projective = Self::GroupedG2Projective,
-        > + From<Self::GroupedG2Projective>
-        + Into<Self::GroupedG2Projective>
-        + Into<Self::G2Prepared>
-        + Group<ScalarField = Self::Fr>;
-}
+//     type GroupedG2Affine: AffineCurve<
+//             BaseField = Self::Fqe,
+//             ScalarField = Self::Fr,
+//             Projective = Self::GroupedG2Projective,
+//         > + From<Self::GroupedG2Projective>
+//         + Into<Self::GroupedG2Projective>
+//         + Into<Self::G2Prepared>
+//         + Group<ScalarField = Self::Fr>;
+// }
+
+pub trait GroupedAffine<C: AffineCurve> {}
+
+impl<C: AffineCurve> GroupedAffine<C> for C {}
+
+pub trait GroupedProjective<C: ProjectiveCurve> {}
 
-pub trait PairingShare<E: ExtendedPairingEngine>:
+pub trait PairingShare<E: PairingEngine>:
     Clone + Copy + Debug + 'static + Send + Sync + PartialEq + Eq
 {
     type FrShare: FieldShare<E::Fr>;
@@ -59,8 +65,8 @@ pub trait PairingShare<E: ExtendedPairingEngine>:
 
     // type hoge: E::G1Affine;
 
-    type G1AffineShare: GroupShare<E::GroupedG1Affine>;
-    type G2AffineShare: GroupShare<E::GroupedG2Affine>;
-    type G1ProjectiveShare: GroupShare<E::GroupedG1Projective>;
-    type G2ProjectiveShare: GroupShare<E::GroupedG2Projective>;
+    type G1AffineShare: GroupShare<E::G1Affine>;
+    type G2AffineShare: GroupShare<E::G2Affine>;
+    type G1ProjectiveShare: GroupShare<E::G1Projective>;
+    type G2ProjectiveShare: GroupShare<E::G2Projective>;
 }
diff --git a/src/wire/group.rs b/src/wire/group.rs
index 6305f3b3..3f1af8dd 100644
--- a/src/wire/group.rs
+++ b/src/wire/group.rs
@@ -1,7 +1,18 @@
+use std::fmt::{self, Display};
+use std::io::{self, Read, Write};
+use std::ops::*;
+
+use std::iter::Sum;
+
 use ark_ec::{group::Group, AffineCurve};
+use ark_ff::prelude::*;
+use ark_ff::{FromBytes, ToBytes};
+use rand::Rng;
 
 use crate::share::group::GroupShare;
 
+use super::field::MpcField;
+
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum MpcGroup<G: Group, S: GroupShare<G>> {
     Public(G),
@@ -13,3 +24,189 @@ pub enum MpcGroup<G: Group, S: GroupShare<G>> {
 //     Public(G),
 //     Shared(S),
 // }
+
+impl<G: Group, S: GroupShare<G>> Display for MpcGroup<G, S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> ToBytes for MpcGroup<G, S> {
+    fn write<W: ark_serialize::Write>(&self, writer: W) -> io::Result<()> {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> FromBytes for MpcGroup<G, S> {
+    fn read<R: Read>(reader: R) -> io::Result<Self> {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> UniformRand for MpcGroup<G, S> {
+    fn rand<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Sum for MpcGroup<G, S> {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        todo!()
+    }
+}
+
+impl<'a, G: Group, S: GroupShare<G>> Sum<&'a MpcGroup<G, S>> for MpcGroup<G, S> {
+    fn sum<I: Iterator<Item = &'a MpcGroup<G, S>>>(iter: I) -> Self {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Neg for MpcGroup<G, S> {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        todo!()
+    }
+}
+
+// impl_ref_ops!(Add, AddAssign, add, add_assign, Group, GroupShare, MpcGroup);
+// impl_ref_ops!(Sub, SubAssign, sub, sub_assign, Group, GroupShare, MpcGroup);
+
+impl<G: Group, S: GroupShare<G>> AddAssign for MpcGroup<G, S> {
+    fn add_assign(&mut self, rhs: Self) {
+        todo!()
+    }
+}
+
+impl<'a, G: Group, S: GroupShare<G>> AddAssign<&'a MpcGroup<G, S>> for MpcGroup<G, S> {
+    fn add_assign(&mut self, rhs: &'a MpcGroup<G, S>) {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Add for MpcGroup<G, S> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        todo!()
+    }
+}
+
+impl<'a, G: Group, S: GroupShare<G>> Add<&'a MpcGroup<G, S>> for MpcGroup<G, S> {
+    type Output = Self;
+
+    fn add(self, rhs: &'a MpcGroup<G, S>) -> Self::Output {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> SubAssign for MpcGroup<G, S> {
+    fn sub_assign(&mut self, rhs: Self) {
+        todo!()
+    }
+}
+
+impl<'a, G: Group, S: GroupShare<G>> SubAssign<&'a MpcGroup<G, S>> for MpcGroup<G, S> {
+    fn sub_assign(&mut self, rhs: &'a MpcGroup<G, S>) {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Sub for MpcGroup<G, S> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        todo!()
+    }
+}
+
+impl<'a, G: Group, S: GroupShare<G>> Sub<&'a MpcGroup<G, S>> for MpcGroup<G, S> {
+    type Output = Self;
+
+    fn sub(self, rhs: &'a MpcGroup<G, S>) -> Self::Output {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Zero for MpcGroup<G, S> {
+    fn zero() -> Self {
+        todo!()
+    }
+
+    fn is_zero(&self) -> bool {
+        todo!()
+    }
+}
+
+impl<G: Group, S: GroupShare<G>> Default for MpcGroup<G, S> {
+    fn default() -> Self {
+        todo!()
+    }
+}
+
+// impl<T: Group, S: GroupShare<T>> Mul<MpcField<T::ScalarField, S::FieldShare>> for MpcGroup<T, S> {
+//     type Output = Self;
+//     #[inline]
+//     fn mul(mut self, other: MpcField<T::ScalarField, S::FieldShare>) -> Self::Output {
+//         self *= &other;
+//         self
+//     }
+// }
+
+// impl<'a, T: Group, S: GroupShare<T>> Mul<&'a MpcField<T::ScalarField, S::FieldShare>>
+//     for MpcGroup<T, S>
+// {
+//     type Output = Self;
+//     #[inline]
+//     fn mul(mut self, other: &MpcField<T::ScalarField, S::FieldShare>) -> Self::Output {
+//         self *= other;
+//         self
+//     }
+// }
+impl<T: Group, S: GroupShare<T>> MulAssign<MpcField<T::ScalarField, S::FieldShare>>
+    for MpcGroup<T, S>
+{
+    #[inline]
+    fn mul_assign(&mut self, other: MpcField<T::ScalarField, S::FieldShare>) {
+        *self *= &other;
+    }
+}
+impl<'a, T: Group, S: GroupShare<T>> MulAssign<&'a MpcField<T::ScalarField, S::FieldShare>>
+    for MpcGroup<T, S>
+{
+    #[inline]
+    fn mul_assign(&mut self, other: &MpcField<T::ScalarField, S::FieldShare>) {
+        match self {
+            // for some reason, a two-stage match (rather than a tuple match) avoids moving
+            // self
+            MpcGroup::Public(x) => match other {
+                MpcField::Public(y) => {
+                    *x *= *y;
+                }
+                MpcField::Shared(y) => {
+                    todo!()
+                }
+            },
+            MpcGroup::Shared(x) => match other {
+                MpcField::Public(y) => {
+                    todo!()
+                }
+                MpcField::Shared(y) => {
+                    todo!()
+                }
+            },
+        }
+    }
+}
+
+impl<T: Group, S: GroupShare<T>> Group for MpcGroup<T, S> {
+    type ScalarField = MpcField<T::ScalarField, S::FieldShare>;
+
+    fn double(&self) -> Self {
+        todo!()
+    }
+
+    fn double_in_place(&mut self) -> &mut Self {
+        todo!()
+    }
+}
diff --git a/src/wire/pairing.rs b/src/wire/pairing.rs
index 057d85dc..2f2f786e 100644
--- a/src/wire/pairing.rs
+++ b/src/wire/pairing.rs
@@ -8,6 +8,7 @@ use std::ops::*;
 
 use zeroize::Zeroize;
 
+use ark_ec::group::Group;
 use ark_ec::{AffineCurve, PairingEngine, ProjectiveCurve};
 use ark_ff::bytes::{FromBytes, ToBytes};
 use ark_ff::prelude::*;
@@ -17,8 +18,6 @@ use ark_serialize::{
     CanonicalSerializeWithFlags, Flags, SerializationError,
 };
 
-use crate::share::pairing::ExtendedPairingEngine;
-
 use super::super::share::field::ExtFieldShare;
 use super::super::share::pairing::PairingShare;
 use super::field::MpcField;
@@ -34,8 +33,8 @@ use derivative::Derivative;
     Eq(bound = "E::G1Affine: Eq"),
     Hash(bound = "E::G1Affine: Hash")
 )]
-pub struct MpcG1Affine<E: ExtendedPairingEngine, PS: PairingShare<E>> {
-    pub val: MpcGroup<E::GroupedG1Affine, PS::G1AffineShare>,
+pub struct MpcG1Affine<E: PairingEngine, PS: PairingShare<E>> {
+    pub val: MpcGroup<E::G1Affine, PS::G1AffineShare>,
 }
 
 #[derive(Debug, Derivative, Clone, Copy, Eq)]
@@ -43,13 +42,13 @@ pub struct MpcG1Affine<E: ExtendedPairingEngine, PS: PairingShare<E>> {
     PartialEq(bound = "E::G1Affine: PartialEq"),
     Hash(bound = "E::G1Affine: Hash")
 )]
-pub struct MpcG1Projective<E: ExtendedPairingEngine, PS: PairingShare<E>> {
-    pub val: MpcGroup<E::GroupedG1Projective, PS::G1ProjectiveShare>,
+pub struct MpcG1Projective<E: PairingEngine, PS: PairingShare<E>> {
+    pub val: MpcGroup<E::G1Projective, PS::G1ProjectiveShare>,
 }
 
 #[derive(Debug, Clone, Derivative)]
 #[derivative(Default(bound = "E::G1Prepared: Default"))]
-pub struct MpcG1Prep<E: ExtendedPairingEngine, PS: PairingShare<E>> {
+pub struct MpcG1Prep<E: PairingEngine, PS: PairingShare<E>> {
     pub val: E::G1Prepared,
     _phantom: PhantomData<(E, PS)>,
 }
@@ -62,8 +61,8 @@ pub struct MpcG1Prep<E: ExtendedPairingEngine, PS: PairingShare<E>> {
     Eq(bound = "E::G1Affine: Eq"),
     Hash(bound = "E::G1Affine: Hash")
 )]
-pub struct MpcG2Affine<E: ExtendedPairingEngine, PS: PairingShare<E>> {
-    pub val: MpcGroup<E::GroupedG2Affine, PS::G2AffineShare>,
+pub struct MpcG2Affine<E: PairingEngine, PS: PairingShare<E>> {
+    pub val: MpcGroup<E::G2Affine, PS::G2AffineShare>,
 }
 
 #[derive(Debug, Derivative, Clone, Copy, Eq)]
@@ -71,13 +70,13 @@ pub struct MpcG2Affine<E: ExtendedPairingEngine, PS: PairingShare<E>> {
     PartialEq(bound = "E::G1Affine: PartialEq"),
     Hash(bound = "E::G1Affine: Hash")
 )]
-pub struct MpcG2Projective<E: ExtendedPairingEngine, PS: PairingShare<E>> {
-    pub val: MpcGroup<E::GroupedG2Projective, PS::G2ProjectiveShare>,
+pub struct MpcG2Projective<E: PairingEngine, PS: PairingShare<E>> {
+    pub val: MpcGroup<E::G2Projective, PS::G2ProjectiveShare>,
 }
 
 #[derive(Debug, Clone, Derivative)]
 #[derivative(Default(bound = "E::G1Prepared: Default"))]
-pub struct MpcG2Prep<E: ExtendedPairingEngine, PS: PairingShare<E>> {
+pub struct MpcG2Prep<E: PairingEngine, PS: PairingShare<E>> {
     pub val: E::G2Prepared,
     _phantom: PhantomData<(E, PS)>,
 }
@@ -96,11 +95,11 @@ pub struct MpcExtField<F: Field, FS: ExtFieldShare<F>> {
 
 #[derive(Derivative)]
 #[derivative(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct MpcPairingEngine<E: ExtendedPairingEngine, PS: PairingShare<E>> {
+pub struct MpcPairingEngine<E: PairingEngine, PS: PairingShare<E>> {
     _phantom: PhantomData<(E, PS)>,
 }
 
-impl<E: ExtendedPairingEngine, PS: PairingShare<E>> PairingEngine for MpcPairingEngine<E, PS> {
+impl<E: PairingEngine, PS: PairingShare<E>> PairingEngine for MpcPairingEngine<E, PS> {
     type Fr = MpcField<E::Fr, PS::FrShare>;
     type G1Projective = MpcG1Projective<E, PS>;
     type G1Affine = MpcG1Affine<E, PS>;
@@ -485,7 +484,7 @@ macro_rules! impl_pairing_curve_wrapper {
 
 impl_pairing_curve_wrapper!(
     MpcGroup,
-    ExtendedPairingEngine,
+    PairingEngine,
     PairingShare,
     G1Affine,
     G1AffineShare,
@@ -493,7 +492,7 @@ impl_pairing_curve_wrapper!(
 );
 impl_pairing_curve_wrapper!(
     MpcGroup,
-    ExtendedPairingEngine,
+    PairingEngine,
     PairingShare,
     G1Projective,
     G1ProjectiveShare,
@@ -501,7 +500,7 @@ impl_pairing_curve_wrapper!(
 );
 impl_pairing_curve_wrapper!(
     MpcGroup,
-    ExtendedPairingEngine,
+    PairingEngine,
     PairingShare,
     G2Affine,
     G2AffineShare,
@@ -509,7 +508,7 @@ impl_pairing_curve_wrapper!(
 );
 impl_pairing_curve_wrapper!(
     MpcGroup,
-    ExtendedPairingEngine,
+    PairingEngine,
     PairingShare,
     G2Projective,
     G2ProjectiveShare,
@@ -520,31 +519,42 @@ impl_ext_field_wrapper!(MpcField, MpcExtField);
 
 macro_rules! impl_aff_proj {
     ($w_prep:ident, $prep:ident, $w_aff:ident, $w_pro:ident, $aff:ident, $pro:ident, $g_name:ident, $w_base:ident, $base:ident, $base_share:ident, $share_aff:ident, $share_proj:ident) => {
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> From<$w_pro<E, PS>> for $w_aff<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> Group for $w_aff<E, PS> {
+            type ScalarField = MpcField<E::Fr, PS::FrShare>;
+
+            fn double(&self) -> Self {
+                todo!()
+            }
+
+            fn double_in_place(&mut self) -> &mut Self {
+                todo!()
+            }
+        }
+        impl<E: PairingEngine, PS: PairingShare<E>> From<$w_pro<E, PS>> for $w_aff<E, PS> {
             fn from(p: $w_pro<E, PS>) -> Self {
                 todo!()
             }
         }
 
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> From<$w_aff<E, PS>> for $w_pro<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> From<$w_aff<E, PS>> for $w_pro<E, PS> {
             fn from(p: $w_aff<E, PS>) -> Self {
                 todo!()
             }
         }
 
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> From<$w_aff<E, PS>> for $w_prep<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> From<$w_aff<E, PS>> for $w_prep<E, PS> {
             fn from(p: $w_aff<E, PS>) -> Self {
                 todo!()
             }
         }
 
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> ToBytes for $w_prep<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> ToBytes for $w_prep<E, PS> {
             fn write<W: Write>(&self, writer: W) -> io::Result<()> {
                 todo!()
             }
         }
 
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> AffineCurve for $w_aff<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> AffineCurve for $w_aff<E, PS> {
             type ScalarField = MpcField<E::Fr, PS::FrShare>;
             const COFACTOR: &'static [u64] = E::$aff::COFACTOR;
             type BaseField = $w_base<E::$base, PS::$base_share>;
@@ -574,7 +584,7 @@ macro_rules! impl_aff_proj {
             }
         }
 
-        impl<E: ExtendedPairingEngine, PS: PairingShare<E>> ProjectiveCurve for $w_pro<E, PS> {
+        impl<E: PairingEngine, PS: PairingShare<E>> ProjectiveCurve for $w_pro<E, PS> {
             type ScalarField = MpcField<E::Fr, PS::FrShare>;
 
             // aff?pro?