Bidirectional Sync (Part 2)

.gitignore

@@ -2,6 +2,7 @@
 .direnv
 .DS_Store
 .idea
+.vscode
 
 tmp
 *.log

chain-signatures/node/src/protocol/presignature.rs

@@ -7,6 +7,7 @@ use crate::protocol::contract::primitives::intersect_vec;
 use crate::protocol::posit::PositInternalAction;
 use crate::protocol::MpcSignProtocol;
 use crate::storage::presignature_storage::{PresignatureSlot, PresignatureStorage};
+use crate::storage::protocol_storage::ProtocolArtifact;
 use crate::storage::triple_storage::{TriplesTaken, TriplesTakenDropper};
 use crate::storage::TripleStorage;
 use crate::types::{PresignatureProtocol, SecretKeyShare};
@@ -56,14 +57,18 @@ impl FullPresignatureId {
 pub struct Presignature {
     pub id: PresignatureId,
     pub output: PresignOutput<Secp256k1>,
+    /// Original protocol participants
     pub participants: Vec<Participant>,
+    /// Nodes still holding their share of the artifact
+    pub holders: Option<Vec<Participant>>,
 }
 
 impl fmt::Debug for Presignature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Presignature")
             .field("id", &self.id)
             .field("participants", &self.participants)
+            .field("holders", &self.holders)
             .finish()
     }
 }
@@ -106,6 +111,7 @@ impl<'de> Deserialize<'de> for Presignature {
                 k: fields.output_k,
                 sigma: fields.output_sigma,
             },
+            holders: None,
             participants: fields.participants,
         })
     }
@@ -262,6 +268,7 @@ impl PresignatureGenerator {
                         id: self.id,
                         output,
                         participants: self.participants.clone(),
+                        holders: Some(self.participants.clone()),
                     };
                     if self.owner == me {
                         tracing::info!(id = self.id, "assigning presignature to myself");
@@ -478,8 +485,12 @@ impl PresignatureSpawner {
         };
 
         let pair_id = triples.artifact.id;
-        // note: only one of the pair's participants is needed since they are the same.
-        let participants = intersect_vec(&[active, &triples.artifact.triple0.public.participants]);
+        // use holders (not original participants) since some nodes may have lost the artifact.
+        let Some(holders) = triples.artifact.holders() else {
+            tracing::error!(?pair_id, "holders not set on taken triple pair");
+            return;
+        };
+        let participants = intersect_vec(&[active, holders]);
         if participants.len() < self.threshold {
             tracing::warn!(
                 ?pair_id,
@@ -875,6 +886,7 @@ mod tests {
                 sigma: <Secp256k1 as CurveArithmetic>::Scalar::ONE,
             },
             participants: vec![Participant::from(1), Participant::from(2)],
+            holders: None,
         };
 
         // Serialize Presignature to JSON

chain-signatures/node/src/protocol/signature.rs

@@ -13,6 +13,7 @@ use crate::protocol::presignature::PresignatureId;
 use crate::protocol::Chain;
 use crate::rpc::{ContractStateWatcher, RpcChannel};
 use crate::storage::presignature_storage::{PresignatureTaken, PresignatureTakenDropper};
+use crate::storage::protocol_storage::ProtocolArtifact;
 use crate::storage::PresignatureStorage;
 use crate::types::SignatureProtocol;
 use crate::util::{AffinePointExt, JoinMap, TimeoutBudget};
@@ -277,7 +278,14 @@ impl SignOrganizer {
             let fetch = tokio::time::timeout(remaining, async {
                 loop {
                     if let Some(taken) = ctx.presignatures.take_mine(ctx.me).await {
-                        let participants = intersect_vec(&[&taken.artifact.participants, &active]);
+                        let Some(holders) = taken.artifact.holders() else {
+                            tracing::error!(
+                                id = taken.artifact.id,
+                                "holders not set on taken presignature"
+                            );
+                            continue;
+                        };
+                        let participants = intersect_vec(&[holders, &active]);
                         if participants.len() < ctx.threshold {
                             recycle.push(taken);
                             continue;
@@ -700,7 +708,7 @@ impl SignGenerating {
         );
 
         let presignature_pending = if let Some(taken) = self.presignature.take() {
-            PendingPresignature::Available(taken)
+            PendingPresignature::Available(Box::new(taken))
         } else {
             PendingPresignature::InStorage(
                 self.presignature_id,
@@ -1394,7 +1402,7 @@ impl Drop for SignatureSpawnerTask {
 }
 
 enum PendingPresignature {
-    Available(PresignatureTaken),
+    Available(Box<PresignatureTaken>),
     InStorage(PresignatureId, Participant, PresignatureStorage),
 }
 
@@ -1408,7 +1416,7 @@ impl PendingPresignature {
 
     pub async fn fetch(self, timeout: Duration) -> Option<PresignatureTaken> {
         let (id, storage, owner) = match self {
-            PendingPresignature::Available(taken) => return Some(taken),
+            PendingPresignature::Available(taken) => return Some(*taken),
             PendingPresignature::InStorage(id, owner, storage) => (id, storage, owner),
         };