nits

Author: patrick-ogrady

consensus/src/marshal/coding/shards/engine.rs

@@ -614,8 +614,12 @@ where
         };
         let participants_len = u64::try_from(scheme.participants().len())
             .expect("participant count impossibly out of bounds");
-        let progressed =
-            state.on_network_shard(peer, shard, InsertCtx::new(&scheme), &mut self.blocker);
+        let progressed = state.on_network_shard(
+            peer,
+            shard,
+            InsertCtx::new(scheme.as_ref()),
+            &mut self.blocker,
+        );
         if progressed {
             state = self
                 .try_transition_state(commitment, participants_len, state)
@@ -905,7 +909,7 @@ where
         let mut progressed = false;
         let participants_len = u64::try_from(scheme.participants().len())
             .expect("participant count impossibly out of bounds");
-        let ctx = InsertCtx::new(&scheme);
+        let ctx = InsertCtx::new(scheme.as_ref());
         for (peer, shard) in buffered {
             progressed |= state.on_network_shard(peer, shard, ctx, &mut self.blocker);
         }

consensus/src/marshal/core/actor.rs

@@ -1318,8 +1318,12 @@ where
                         .iter()
                         .map(PendingVerification::as_subject_and_certificate)
                         .collect();
-                    let verified =
-                        verify_certificates(&mut context, &scheme, &cert_refs, &strategy);
+                    let verified = verify_certificates(
+                        &mut context,
+                        scheme.as_ref(),
+                        &cert_refs,
+                        &strategy,
+                    );
                     (delivers, verified)
                 });
             let (returned, verified) = handle.await.expect("strategy task failed");
@@ -1351,8 +1355,12 @@ where
                             .iter()
                             .map(|&i| delivers[i].as_subject_and_certificate())
                             .collect();
-                        let results =
-                            verify_certificates(&mut context, &scheme, &group_refs, &strategy);
+                        let results = verify_certificates(
+                            &mut context,
+                            scheme.as_ref(),
+                            &group_refs,
+                            &strategy,
+                        );
                         (delivers, indices, results)
                     });
                 let (returned, indices, results) = handle.await.expect("strategy task failed");

cryptography/src/certificate.rs

@@ -391,163 +391,6 @@ pub trait Scheme: Clone + Debug + Send + Sync + 'static {
     fn certificate_codec_config_unbounded() -> <Self::Certificate as Read>::Cfg;
 }
 
-impl<S: Scheme> Scheme for Arc<S> {
-    type Subject<'a, D: Digest> = S::Subject<'a, D>;
-    type PublicKey = S::PublicKey;
-    type Signature = S::Signature;
-    type Certificate = S::Certificate;
-
-    fn me(&self) -> Option<Participant> {
-        self.as_ref().me()
-    }
-
-    fn participants(&self) -> &Set<Self::PublicKey> {
-        self.as_ref().participants()
-    }
-
-    fn sign<D: Digest>(&self, subject: Self::Subject<'_, D>) -> Option<Attestation<Self>> {
-        self.as_ref().sign(subject).map(|attestation| Attestation {
-            signer: attestation.signer,
-            signature: attestation.signature,
-        })
-    }
-
-    fn verify_attestation<R, D>(
-        &self,
-        rng: &mut R,
-        subject: Self::Subject<'_, D>,
-        attestation: &Attestation<Self>,
-        strategy: &impl Strategy,
-    ) -> bool
-    where
-        R: CryptoRngCore,
-        D: Digest,
-    {
-        let attestation = Attestation::<S> {
-            signer: attestation.signer,
-            signature: attestation.signature.clone(),
-        };
-        self.as_ref()
-            .verify_attestation(rng, subject, &attestation, strategy)
-    }
-
-    fn verify_attestations<R, D, I>(
-        &self,
-        rng: &mut R,
-        subject: Self::Subject<'_, D>,
-        attestations: I,
-        strategy: &impl Strategy,
-    ) -> Verification<Self>
-    where
-        R: CryptoRngCore,
-        D: Digest,
-        I: IntoIterator<Item = Attestation<Self>>,
-        I::IntoIter: Send,
-    {
-        let Verification { verified, invalid } = self.as_ref().verify_attestations::<R, D, _>(
-            rng,
-            subject,
-            attestations
-                .into_iter()
-                .map(|attestation| Attestation::<S> {
-                    signer: attestation.signer,
-                    signature: attestation.signature,
-                }),
-            strategy,
-        );
-        let verified = verified
-            .into_iter()
-            .map(|attestation| Attestation::<Self> {
-                signer: attestation.signer,
-                signature: attestation.signature,
-            })
-            .collect();
-        Verification::new(verified, invalid)
-    }
-
-    fn assemble<I, M>(&self, attestations: I, strategy: &impl Strategy) -> Option<Self::Certificate>
-    where
-        I: IntoIterator<Item = Attestation<Self>>,
-        I::IntoIter: Send,
-        M: Faults,
-    {
-        self.as_ref().assemble::<_, M>(
-            attestations
-                .into_iter()
-                .map(|attestation| Attestation::<S> {
-                    signer: attestation.signer,
-                    signature: attestation.signature,
-                }),
-            strategy,
-        )
-    }
-
-    fn verify_certificate<R, D, M>(
-        &self,
-        rng: &mut R,
-        subject: Self::Subject<'_, D>,
-        certificate: &Self::Certificate,
-        strategy: &impl Strategy,
-    ) -> bool
-    where
-        R: CryptoRngCore,
-        D: Digest,
-        M: Faults,
-    {
-        self.as_ref()
-            .verify_certificate::<_, _, M>(rng, subject, certificate, strategy)
-    }
-
-    fn verify_certificates<'a, R, D, I, M>(
-        &self,
-        rng: &mut R,
-        certificates: I,
-        strategy: &impl Strategy,
-    ) -> bool
-    where
-        R: CryptoRngCore,
-        D: Digest,
-        I: Iterator<Item = (Self::Subject<'a, D>, &'a Self::Certificate)>,
-        M: Faults,
-    {
-        self.as_ref()
-            .verify_certificates::<R, D, I, M>(rng, certificates, strategy)
-    }
-
-    fn verify_certificates_bisect<'a, R, D, M>(
-        &self,
-        rng: &mut R,
-        certificates: &[(Self::Subject<'a, D>, &'a Self::Certificate)],
-        strategy: &impl Strategy,
-    ) -> Vec<bool>
-    where
-        R: CryptoRngCore,
-        D: Digest,
-        Self::Subject<'a, D>: Copy,
-        Self::Certificate: 'a,
-        M: Faults,
-    {
-        self.as_ref()
-            .verify_certificates_bisect::<R, D, M>(rng, certificates, strategy)
-    }
-
-    fn is_attributable() -> bool {
-        S::is_attributable()
-    }
-
-    fn is_batchable() -> bool {
-        S::is_batchable()
-    }
-
-    fn certificate_codec_config(&self) -> <Self::Certificate as Read>::Cfg {
-        self.as_ref().certificate_codec_config()
-    }
-
-    fn certificate_codec_config_unbounded() -> <Self::Certificate as Read>::Cfg {
-        S::certificate_codec_config_unbounded()
-    }
-}
-
 /// Supplies the signing scheme for a given scope.
 ///
 /// This trait uses an associated `Scope` type, allowing implementations to work