Merge branch 'eichhorl/rm-tecdsa-inputs-proto' into 'master'

chore(ecdsa): CON-1208 CON-1216 Remove unused proto definitions

These structures are no longer persisted in the block payload and can therefore be removed.

Additionally, we remove the redundant `key_transcript_ref` from `ThresholdEcdsaSigInputsRef`, as this reference also exists in the input's `PreSignatureQuadrupleRef`. 

See merge request dfinity-lab/public/ic!19781

Author: eichhorl

rs/consensus/src/ecdsa/test_utils.rs

@@ -290,7 +290,6 @@ impl From<&ThresholdEcdsaSigInputs> for TestSigInputs {
                     .unwrap(),
                 key_unmasked_ref: UnmaskedTranscript::try_from((height, key)).unwrap(),
             },
-            key_transcript_ref: UnmaskedTranscript::try_from((height, key)).unwrap(),
         };
         TestSigInputs {
             idkg_transcripts,
@@ -1253,7 +1252,6 @@ pub(crate) fn create_ecdsa_sig_inputs_with_args(
         [0u8; 32],
         Randomness::from([0_u8; 32]),
         presig_quadruple_ref,
-        key_unmasked_ref,
     );
 
     TestSigInputs {

rs/consensus/src/ecdsa/utils.rs

@@ -246,13 +246,11 @@ pub(super) fn build_signature_inputs(
     let nonce = Id::from(context.nonce?);
     let inputs = match (pre_signature, &context.args) {
         (PreSignatureRef::Ecdsa(pre_sig), ThresholdArguments::Ecdsa(args)) => {
-            let key_transcript_ref = pre_sig.key_unmasked_ref;
             ThresholdSigInputsRef::Ecdsa(ThresholdEcdsaSigInputsRef::new(
                 extended_derivation_path,
                 args.message_hash,
                 nonce,
                 pre_sig,
-                key_transcript_ref,
             ))
         }
         (PreSignatureRef::Schnorr(pre_sig), ThresholdArguments::Schnorr(args)) => {

rs/protobuf/def/types/v1/idkg.proto

@@ -39,25 +39,6 @@ message EcdsaKeyTranscript {
   registry.crypto.v1.MasterPublicKeyId master_key_id = 4;
 }
 
-message OngoingSignature {
-  RequestId request_id = 1;
-  ThresholdEcdsaSigInputsRef sig_inputs = 2;
-}
-
-message AvailableQuadruple {
-  reserved 3;
-  reserved "key_id";
-  uint64 pre_signature_id = 1;
-  PreSignatureQuadrupleRef quadruple = 2;
-}
-
-message QuadrupleInProgress {
-  reserved 3;
-  reserved "key_id";
-  uint64 pre_signature_id = 1;
-  QuadrupleInCreation quadruple = 2;
-}
-
 message AvailablePreSignature {
   uint64 pre_signature_id = 1;
   PreSignatureRef pre_signature = 2;
@@ -188,14 +169,6 @@ message PreSignatureQuadrupleRef {
   registry.crypto.v1.EcdsaKeyId key_id = 6;
 }
 
-message ThresholdEcdsaSigInputsRef {
-  registry.subnet.v1.ExtendedDerivationPath derivation_path = 1;
-  bytes hashed_message = 2;
-  bytes nonce = 3;
-  PreSignatureQuadrupleRef presig_quadruple_ref = 4;
-  UnmaskedTranscript key_transcript_ref = 5;
-}
-
 message TranscriptInCreation {
   registry.crypto.v1.SchnorrKeyId key_id = 1;
   RandomUnmaskedTranscriptParams blinder_unmasked_config = 2;

rs/protobuf/src/gen/types/types.v1.rs

@@ -440,30 +440,6 @@ pub struct EcdsaKeyTranscript {
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OngoingSignature {
-    #[prost(message, optional, tag = "1")]
-    pub request_id: ::core::option::Option<RequestId>,
-    #[prost(message, optional, tag = "2")]
-    pub sig_inputs: ::core::option::Option<ThresholdEcdsaSigInputsRef>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AvailableQuadruple {
-    #[prost(uint64, tag = "1")]
-    pub pre_signature_id: u64,
-    #[prost(message, optional, tag = "2")]
-    pub quadruple: ::core::option::Option<PreSignatureQuadrupleRef>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QuadrupleInProgress {
-    #[prost(uint64, tag = "1")]
-    pub pre_signature_id: u64,
-    #[prost(message, optional, tag = "2")]
-    pub quadruple: ::core::option::Option<QuadrupleInCreation>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AvailablePreSignature {
     #[prost(uint64, tag = "1")]
     pub pre_signature_id: u64,
@@ -674,21 +650,6 @@ pub struct PreSignatureQuadrupleRef {
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ThresholdEcdsaSigInputsRef {
-    #[prost(message, optional, tag = "1")]
-    pub derivation_path:
-        ::core::option::Option<super::super::registry::subnet::v1::ExtendedDerivationPath>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub hashed_message: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "3")]
-    pub nonce: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "4")]
-    pub presig_quadruple_ref: ::core::option::Option<PreSignatureQuadrupleRef>,
-    #[prost(message, optional, tag = "5")]
-    pub key_transcript_ref: ::core::option::Option<UnmaskedTranscript>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TranscriptInCreation {
     #[prost(message, optional, tag = "1")]
     pub key_id: ::core::option::Option<super::super::registry::crypto::v1::SchnorrKeyId>,

rs/types/types/src/consensus/idkg/common.rs

@@ -1112,7 +1112,6 @@ fn err_schnorr(err: ThresholdSchnorrSigInputsError) -> ThresholdSigInputsResult
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-#[allow(clippy::large_enum_variant)]
 pub enum ThresholdSigInputsRef {
     Ecdsa(ThresholdEcdsaSigInputsRef),
     Schnorr(ThresholdSchnorrSigInputsRef),

rs/types/types/src/consensus/idkg/ecdsa.rs

@@ -404,7 +404,6 @@ pub struct ThresholdEcdsaSigInputsRef {
     pub hashed_message: [u8; 32],
     pub nonce: Randomness,
     pub presig_quadruple_ref: PreSignatureQuadrupleRef,
-    pub key_transcript_ref: UnmaskedTranscript,
 }
 
 #[derive(Clone, Debug)]
@@ -420,14 +419,12 @@ impl ThresholdEcdsaSigInputsRef {
         hashed_message: [u8; 32],
         nonce: Randomness,
         presig_quadruple_ref: PreSignatureQuadrupleRef,
-        key_transcript_ref: UnmaskedTranscript,
     ) -> Self {
         Self {
             derivation_path,
             hashed_message,
             nonce,
             presig_quadruple_ref,
-            key_transcript_ref,
         }
     }
 
@@ -441,7 +438,7 @@ impl ThresholdEcdsaSigInputsRef {
             .translate(resolver)
             .map_err(ThresholdEcdsaSigInputsError::PreSignatureQuadruple)?;
         let key_transcript = resolver
-            .transcript(self.key_transcript_ref.as_ref())
+            .transcript(self.presig_quadruple_ref.key_unmasked_ref.as_ref())
             .map_err(ThresholdEcdsaSigInputsError::KeyTranscript)?;
         ThresholdEcdsaSigInputs::new(
             &self.derivation_path,
@@ -453,62 +450,3 @@ impl ThresholdEcdsaSigInputsRef {
         .map_err(ThresholdEcdsaSigInputsError::Failed)
     }
 }
-
-impl From<&ThresholdEcdsaSigInputsRef> for pb::ThresholdEcdsaSigInputsRef {
-    fn from(sig_inputs: &ThresholdEcdsaSigInputsRef) -> Self {
-        Self {
-            derivation_path: Some((sig_inputs.derivation_path.clone()).into()),
-            hashed_message: sig_inputs.hashed_message.to_vec(),
-            nonce: sig_inputs.nonce.get().to_vec(),
-            presig_quadruple_ref: Some((&sig_inputs.presig_quadruple_ref).into()),
-            key_transcript_ref: Some((&sig_inputs.key_transcript_ref).into()),
-        }
-    }
-}
-
-impl TryFrom<&pb::ThresholdEcdsaSigInputsRef> for ThresholdEcdsaSigInputsRef {
-    type Error = ProxyDecodeError;
-    fn try_from(sig_inputs: &pb::ThresholdEcdsaSigInputsRef) -> Result<Self, Self::Error> {
-        let derivation_path: ExtendedDerivationPath = try_from_option_field(
-            sig_inputs.derivation_path.clone(),
-            "ThresholdEcdsaSigInputsRef::derivation_path",
-        )?;
-
-        if sig_inputs.hashed_message.len() != 32 {
-            return Err(ProxyDecodeError::Other(format!(
-                "ThresholdEcdsaSigInputsRef:: Invalid hashed_message length: {:?}",
-                sig_inputs.nonce.len()
-            )));
-        }
-        let mut hashed_message = [0; 32];
-        hashed_message.copy_from_slice(&sig_inputs.hashed_message[0..32]);
-
-        if sig_inputs.nonce.len() != 32 {
-            return Err(ProxyDecodeError::Other(format!(
-                "ThresholdEcdsaSigInputsRef:: Invalid nonce length: {:?}",
-                sig_inputs.nonce.len()
-            )));
-        }
-        let mut nonce = [0; 32];
-        nonce.copy_from_slice(&sig_inputs.nonce[0..32]);
-        let nonce = Randomness::from(nonce);
-
-        let presig_quadruple_ref: PreSignatureQuadrupleRef = try_from_option_field(
-            sig_inputs.presig_quadruple_ref.as_ref(),
-            "ThresholdEcdsaSigInputsRef::presig_quadruple_ref",
-        )?;
-
-        let key_transcript_ref: UnmaskedTranscript = try_from_option_field(
-            sig_inputs.key_transcript_ref.as_ref(),
-            "ThresholdEcdsaSigInputsRef::key_transcript_ref",
-        )?;
-
-        Ok(Self::new(
-            derivation_path,
-            hashed_message,
-            nonce,
-            presig_quadruple_ref,
-            key_transcript_ref,
-        ))
-    }
-}