diff --git a/airgapped/airgapped.go b/airgapped/airgapped.go index a74e8d5..e183dd6 100644 --- a/airgapped/airgapped.go +++ b/airgapped/airgapped.go @@ -195,9 +195,9 @@ func (am *AirgappedMachine) HandleOperation(operation client.Operation) (client. err = am.handleStateDkgMasterKeyAwaitConfirmations(&operation) case signing_proposal_fsm.StateSigningAwaitConfirmations: err = am.handleStateSigningAwaitConfirmations(&operation) - case signing_proposal_fsm.StateSigningAwaitPartialKeys: + case signing_proposal_fsm.StateSigningAwaitPartialSigns: err = am.handleStateSigningAwaitPartialSigns(&operation) - case signing_proposal_fsm.StateSigningPartialKeysCollected: + case signing_proposal_fsm.StateSigningPartialSignsCollected: err = am.reconstructThresholdSignature(&operation) default: err = fmt.Errorf("invalid operation type: %s", operation.Type) diff --git a/airgapped/airgapped_test.go b/airgapped/airgapped_test.go index 5735370..e09f549 100644 --- a/airgapped/airgapped_test.go +++ b/airgapped/airgapped_test.go @@ -7,6 +7,7 @@ import ( client "github.com/depools/dc4bc/client/types" "github.com/depools/dc4bc/fsm/fsm" "github.com/depools/dc4bc/fsm/state_machines/dkg_proposal_fsm" + "github.com/depools/dc4bc/fsm/state_machines/signature_proposal_fsm" "github.com/depools/dc4bc/fsm/state_machines/signing_proposal_fsm" "github.com/depools/dc4bc/fsm/types/requests" "github.com/depools/dc4bc/fsm/types/responses" @@ -100,6 +101,7 @@ func createOperation(t *testing.T, opType string, to string, req interface{}) cl func TestAirgappedAllSteps(t *testing.T) { nodesCount := 10 + threshold := 3 participants := make([]string, nodesCount) for i := 0; i < nodesCount; i++ { participants[i] = fmt.Sprintf("Participant#%d", i) @@ -111,6 +113,7 @@ func TestAirgappedAllSteps(t *testing.T) { if err != nil { t.Fatalf("failed to create airgapped machine: %v", err) } + am.SetAddress(participants[i]) node := Node{ ParticipantID: i, Participant: participants[i], @@ -119,6 +122,25 @@ func TestAirgappedAllSteps(t *testing.T) { tr.nodes = append(tr.nodes, &node) } + var initReq responses.SignatureProposalParticipantInvitationsResponse + for _, n := range tr.nodes { + entry := &responses.SignatureProposalParticipantInvitationEntry{ + ParticipantId: n.ParticipantID, + Addr: n.Participant, + Threshold: threshold, + } + initReq = append(initReq, entry) + } + op := createOperation(t, string(signature_proposal_fsm.StateAwaitParticipantsConfirmations), "", initReq) + runStep(tr, func(n *Node, wg *sync.WaitGroup) { + defer wg.Done() + + _, err := n.Machine.HandleOperation(op) + if err != nil { + t.Fatalf("%s: failed to handle operation %s: %v", n.Participant, op.Type, err) + } + }) + // get commits var getCommitsRequest responses.DKGProposalPubKeysParticipantResponse for _, n := range tr.nodes { @@ -133,7 +155,7 @@ func TestAirgappedAllSteps(t *testing.T) { } getCommitsRequest = append(getCommitsRequest, entry) } - op := createOperation(t, string(dkg_proposal_fsm.StateDkgCommitsAwaitConfirmations), "", getCommitsRequest) + op = createOperation(t, string(dkg_proposal_fsm.StateDkgCommitsAwaitConfirmations), "", getCommitsRequest) runStep(tr, func(n *Node, wg *sync.WaitGroup) { defer wg.Done() diff --git a/airgapped/bls.go b/airgapped/bls.go index 4306bf1..2762803 100644 --- a/airgapped/bls.go +++ b/airgapped/bls.go @@ -62,7 +62,7 @@ func (am *AirgappedMachine) handleStateSigningAwaitPartialSigns(o *client.Operat if err != nil { return fmt.Errorf("failed to get paricipant id: %w", err) } - req := requests.SigningProposalPartialKeyRequest{ + req := requests.SigningProposalPartialSignRequest{ SigningId: payload.SigningId, ParticipantId: participantID, PartialSign: partialSign, @@ -73,7 +73,7 @@ func (am *AirgappedMachine) handleStateSigningAwaitPartialSigns(o *client.Operat return fmt.Errorf("failed to generate fsm request: %w", err) } - o.Event = signing_proposal_fsm.EventSigningPartialKeyReceived + o.Event = signing_proposal_fsm.EventSigningPartialSignReceived o.ResultMsgs = append(o.ResultMsgs, createMessage(*o, reqBz)) return nil } @@ -93,7 +93,13 @@ func (am *AirgappedMachine) reconstructThresholdSignature(o *client.Operation) e partialSignatures = append(partialSignatures, participant.PartialSign) } - reconstructedSignature, err := am.recoverFullSign(payload.SrcPayload, partialSignatures, o.DKGIdentifier) + dkgInstance, ok := am.dkgInstances[o.DKGIdentifier] + if !ok { + return fmt.Errorf("dkg instance with identifier %s does not exist", o.DKGIdentifier) + } + + reconstructedSignature, err := am.recoverFullSign(payload.SrcPayload, partialSignatures, dkgInstance.Threshold, + dkgInstance.N, o.DKGIdentifier) if err != nil { return fmt.Errorf("failed to reconsruct full signature for msg: %w", err) } @@ -110,13 +116,13 @@ func (am *AirgappedMachine) createPartialSign(msg []byte, dkgIdentifier string) return tbls.Sign(am.suite.(pairing.Suite), blsKeyring.Share, msg) } -func (am *AirgappedMachine) recoverFullSign(msg []byte, sigShares [][]byte, dkgIdentifier string) ([]byte, error) { +func (am *AirgappedMachine) recoverFullSign(msg []byte, sigShares [][]byte, t, n int, dkgIdentifier string) ([]byte, error) { blsKeyring, err := am.loadBLSKeyring(dkgIdentifier) if err != nil { return nil, fmt.Errorf("failed to load blsKeyring: %w", err) } - return tbls.Recover(am.suite.(pairing.Suite), blsKeyring.PubPoly, msg, sigShares, len(sigShares), len(sigShares)) + return tbls.Recover(am.suite.(pairing.Suite), blsKeyring.PubPoly, msg, sigShares, t, n) } func (am *AirgappedMachine) verifySign(msg []byte, fullSignature []byte, dkgIdentifier string) error { diff --git a/airgapped/dkg.go b/airgapped/dkg.go index 0c4acc8..6500836 100644 --- a/airgapped/dkg.go +++ b/airgapped/dkg.go @@ -39,25 +39,26 @@ func (am *AirgappedMachine) handleStateAwaitParticipantsConfirmations(o *client. return fmt.Errorf("failed to unmarshal payload: %w", err) } - if _, ok := am.dkgInstances[o.DKGIdentifier]; ok { - return fmt.Errorf("dkg instance %s already exists", o.DKGIdentifier) - } - - dkgInstance := dkg.Init(am.suite, am.pubKey, am.secKey) - dkgInstance.Threshold = len(payload) - - am.dkgInstances[o.DKGIdentifier] = dkgInstance - pid := -1 for _, r := range payload { if r.Addr == am.ParticipantAddress { pid = r.ParticipantId + break } } if pid < 0 { return fmt.Errorf("failed to determine participant id for DKG with participant address %s", am.ParticipantAddress) } + if _, ok := am.dkgInstances[o.DKGIdentifier]; ok { + return fmt.Errorf("dkg instance %s already exists", o.DKGIdentifier) + } + + dkgInstance := dkg.Init(am.suite, am.pubKey, am.secKey) + dkgInstance.Threshold = payload[0].Threshold //same for everyone + dkgInstance.N = len(payload) + am.dkgInstances[o.DKGIdentifier] = dkgInstance + req := requests.SignatureProposalParticipantRequest{ ParticipantId: pid, CreatedAt: o.CreatedAt, @@ -84,11 +85,9 @@ func (am *AirgappedMachine) handleStateDkgCommitsAwaitConfirmations(o *client.Op dkgInstance, ok := am.dkgInstances[o.DKGIdentifier] if !ok { - dkgInstance = dkg.Init(am.suite, am.pubKey, am.secKey) + return fmt.Errorf("dkg instance with identifier %s does not exist", o.DKGIdentifier) } - dkgInstance.Threshold = len(payload) - if err = json.Unmarshal(o.Payload, &payload); err != nil { return fmt.Errorf("failed to unmarshal payload: %w", err) } diff --git a/client/client.go b/client/client.go index 33418c4..739dc11 100644 --- a/client/client.go +++ b/client/client.go @@ -205,8 +205,8 @@ func (c *Client) ProcessMessage(message storage.Message) error { dpf.StateDkgDealsAwaitConfirmations, dpf.StateDkgResponsesAwaitConfirmations, dpf.StateDkgMasterKeyAwaitConfirmations, - sipf.StateSigningAwaitPartialKeys, - sipf.StateSigningPartialKeysCollected, + sipf.StateSigningAwaitPartialSigns, + sipf.StateSigningPartialSignsCollected, sipf.StateSigningAwaitConfirmations: if resp.Data != nil { bz, err := json.Marshal(resp.Data) diff --git a/client/types/types.go b/client/types/types.go index 0a3db06..a772974 100644 --- a/client/types/types.go +++ b/client/types/types.go @@ -86,8 +86,8 @@ func FSMRequestFromMessage(message storage.Message) (interface{}, error) { return fmt.Errorf("failed to unmarshal fsm req: %v", err), nil } resolvedValue = req - case signing_proposal_fsm.EventSigningPartialKeyReceived: - var req requests.SigningProposalPartialKeyRequest + case signing_proposal_fsm.EventSigningPartialSignReceived: + var req requests.SigningProposalPartialSignRequest if err := json.Unmarshal(message.Data, &req); err != nil { return fmt.Errorf("failed to unmarshal fsm req: %v", err), nil } diff --git a/dkg/dkg.go b/dkg/dkg.go index 1b31ce2..3935566 100644 --- a/dkg/dkg.go +++ b/dkg/dkg.go @@ -26,7 +26,9 @@ type DKG struct { secKey kyber.Scalar suite vss.Suite ParticipantID int - Threshold int + + N int + Threshold int } func Init(suite vss.Suite, pubKey kyber.Point, secKey kyber.Scalar) *DKG { diff --git a/fsm/state_machines/internal/types.go b/fsm/state_machines/internal/types.go index 7d94a8b..c6dcdcf 100644 --- a/fsm/state_machines/internal/types.go +++ b/fsm/state_machines/internal/types.go @@ -43,6 +43,7 @@ type SignatureProposalParticipant struct { // For validation user confirmation: sign(InvitationSecret, PubKey) => user InvitationSecret string Status ConfirmationParticipantStatus + Threshold int UpdatedAt time.Time } @@ -157,8 +158,8 @@ const ( SigningAwaitConfirmation SigningParticipantStatus = iota SigningConfirmed SigningDeclined - SigningAwaitPartialKeys - SigningPartialKeysConfirmed + SigningAwaitPartialSigns + SigningPartialSignsConfirmed SigningError SigningProcess ) @@ -170,10 +171,10 @@ func (s SigningParticipantStatus) String() string { str = "SigningAwaitConfirmation" case SigningConfirmed: str = "SigningConfirmed" - case SigningAwaitPartialKeys: - str = "SigningAwaitPartialKeys" - case SigningPartialKeysConfirmed: - str = "SigningPartialKeysConfirmed" + case SigningAwaitPartialSigns: + str = "SigningAwaitPartialSigns" + case SigningPartialSignsConfirmed: + str = "SigningPartialSignsConfirmed" case SigningError: str = "SigningError" case SigningProcess: diff --git a/fsm/state_machines/provider_test.go b/fsm/state_machines/provider_test.go index fbdde03..80111a4 100644 --- a/fsm/state_machines/provider_test.go +++ b/fsm/state_machines/provider_test.go @@ -975,7 +975,7 @@ func Test_SigningProposal_EventConfirmSigningConfirmation_Positive(t *testing.T) } - compareState(t, sif.StateSigningAwaitPartialKeys, fsmResponse.State) + compareState(t, sif.StateSigningAwaitPartialSigns, fsmResponse.State) response, ok := fsmResponse.Data.(responses.SigningPartialSignsParticipantInvitationsResponse) @@ -991,9 +991,9 @@ func Test_SigningProposal_EventConfirmSigningConfirmation_Positive(t *testing.T) t.Fatalf("expected matched {SrcPayload}") } - testFSMDump[sif.StateSigningAwaitPartialKeys] = testFSMDumpLocal + testFSMDump[sif.StateSigningAwaitPartialSigns] = testFSMDumpLocal - compareDumpNotZero(t, testFSMDump[sif.StateSigningAwaitPartialKeys]) + compareDumpNotZero(t, testFSMDump[sif.StateSigningAwaitPartialSigns]) } func Test_SigningProposal_EventDeclineProposal_Canceled_Participant(t *testing.T) { @@ -1056,7 +1056,7 @@ func Test_SigningProposal_EventSigningPartialKeyReceived_Positive(t *testing.T) participantCounter := participantsCount - testFSMDumpLocal = testFSMDump[sif.StateSigningAwaitPartialKeys] + testFSMDumpLocal = testFSMDump[sif.StateSigningAwaitPartialSigns] for participantId, participant := range testIdMapParticipants { participantCounter-- @@ -1068,9 +1068,9 @@ func Test_SigningProposal_EventSigningPartialKeyReceived_Positive(t *testing.T) compareFSMInstanceNotNil(t, testFSMInstance) inState, _ := testFSMInstance.State() - compareState(t, sif.StateSigningAwaitPartialKeys, inState) + compareState(t, sif.StateSigningAwaitPartialSigns, inState) - fsmResponse, testFSMDumpLocal, err = testFSMInstance.Do(sif.EventSigningPartialKeyReceived, requests.SigningProposalPartialKeyRequest{ + fsmResponse, testFSMDumpLocal, err = testFSMInstance.Do(sif.EventSigningPartialSignReceived, requests.SigningProposalPartialSignRequest{ SigningId: testSigningId, ParticipantId: participantId, PartialSign: participant.DkgPartialKey, @@ -1084,12 +1084,12 @@ func Test_SigningProposal_EventSigningPartialKeyReceived_Positive(t *testing.T) compareFSMResponseNotNil(t, fsmResponse) if participantCounter > 0 { - compareState(t, sif.StateSigningAwaitPartialKeys, fsmResponse.State) + compareState(t, sif.StateSigningAwaitPartialSigns, fsmResponse.State) } } - compareState(t, sif.StateSigningPartialKeysCollected, fsmResponse.State) + compareState(t, sif.StateSigningPartialSignsCollected, fsmResponse.State) response, ok := fsmResponse.Data.(responses.SigningProcessParticipantResponse) @@ -1105,9 +1105,9 @@ func Test_SigningProposal_EventSigningPartialKeyReceived_Positive(t *testing.T) t.Fatalf("expected matched {SrcPayload}") } - testFSMDump[sif.StateSigningPartialKeysCollected] = testFSMDumpLocal + testFSMDump[sif.StateSigningPartialSignsCollected] = testFSMDumpLocal - compareDumpNotZero(t, testFSMDump[sif.StateSigningPartialKeysCollected]) + compareDumpNotZero(t, testFSMDump[sif.StateSigningPartialSignsCollected]) } func Test_DkgProposal_EventSigningRestart_Positive(t *testing.T) { @@ -1116,14 +1116,14 @@ func Test_DkgProposal_EventSigningRestart_Positive(t *testing.T) { testFSMDumpLocal []byte ) - testFSMInstance, err := FromDump(testFSMDump[sif.StateSigningPartialKeysCollected]) + testFSMInstance, err := FromDump(testFSMDump[sif.StateSigningPartialSignsCollected]) compareErrNil(t, err) compareFSMInstanceNotNil(t, testFSMInstance) inState, _ := testFSMInstance.State() - compareState(t, sif.StateSigningPartialKeysCollected, inState) + compareState(t, sif.StateSigningPartialSignsCollected, inState) fsmResponse, testFSMDumpLocal, err = testFSMInstance.Do(sif.EventSigningRestart, requests.DefaultRequest{ CreatedAt: time.Now(), diff --git a/fsm/state_machines/signature_proposal_fsm/actions.go b/fsm/state_machines/signature_proposal_fsm/actions.go index a95a970..7e8bdb2 100644 --- a/fsm/state_machines/signature_proposal_fsm/actions.go +++ b/fsm/state_machines/signature_proposal_fsm/actions.go @@ -46,6 +46,7 @@ func (m *SignatureProposalFSM) actionInitSignatureProposal(inEvent fsm.Event, ar PubKey: participant.PubKey, DkgPubKey: participant.DkgPubKey, Status: internal.SigConfirmationAwaitConfirmation, + Threshold: request.SigningThreshold, UpdatedAt: request.CreatedAt, } @@ -66,6 +67,7 @@ func (m *SignatureProposalFSM) actionInitSignatureProposal(inEvent fsm.Event, ar responseEntry := &responses.SignatureProposalParticipantInvitationEntry{ ParticipantId: participantId, Addr: participant.Addr, + Threshold: participant.Threshold, } responseData = append(responseData, responseEntry) } diff --git a/fsm/state_machines/signing_proposal_fsm/actions.go b/fsm/state_machines/signing_proposal_fsm/actions.go index 8f49959..33db5f4 100644 --- a/fsm/state_machines/signing_proposal_fsm/actions.go +++ b/fsm/state_machines/signing_proposal_fsm/actions.go @@ -188,7 +188,7 @@ func (m *SigningProposalFSM) actionValidateSigningProposalConfirmations(inEvent outEvent = eventSetProposalValidatedInternal for _, participant := range m.payload.SigningProposalPayload.Quorum { - participant.Status = internal.SigningAwaitPartialKeys + participant.Status = internal.SigningAwaitPartialSigns } // Make response @@ -203,19 +203,19 @@ func (m *SigningProposalFSM) actionValidateSigningProposalConfirmations(inEvent return } -func (m *SigningProposalFSM) actionPartialKeyConfirmationReceived(inEvent fsm.Event, args ...interface{}) (outEvent fsm.Event, response interface{}, err error) { +func (m *SigningProposalFSM) actionPartialSignConfirmationReceived(inEvent fsm.Event, args ...interface{}) (outEvent fsm.Event, response interface{}, err error) { m.payloadMu.Lock() defer m.payloadMu.Unlock() if len(args) != 1 { - err = errors.New("{arg0} required {SigningProposalPartialKeyRequest}") + err = errors.New("{arg0} required {SigningProposalPartialSignRequest}") return } - request, ok := args[0].(requests.SigningProposalPartialKeyRequest) + request, ok := args[0].(requests.SigningProposalPartialSignRequest) if !ok { - err = errors.New("cannot cast {arg0} to type {SigningProposalPartialKeyRequest}") + err = errors.New("cannot cast {arg0} to type {SigningProposalPartialSignRequest}") return } @@ -230,14 +230,14 @@ func (m *SigningProposalFSM) actionPartialKeyConfirmationReceived(inEvent fsm.Ev signingProposalParticipant := m.payload.SigningQuorumGet(request.ParticipantId) - if signingProposalParticipant.Status != internal.SigningAwaitPartialKeys { + if signingProposalParticipant.Status != internal.SigningAwaitPartialSigns { err = errors.New(fmt.Sprintf("cannot confirm response with {Status} = {\"%s\"}", signingProposalParticipant.Status)) return } signingProposalParticipant.PartialSign = make([]byte, len(request.PartialSign)) copy(signingProposalParticipant.PartialSign, request.PartialSign) - signingProposalParticipant.Status = internal.SigningPartialKeysConfirmed + signingProposalParticipant.Status = internal.SigningPartialSignsConfirmed signingProposalParticipant.UpdatedAt = request.CreatedAt m.payload.SignatureProposalPayload.UpdatedAt = request.CreatedAt @@ -247,7 +247,7 @@ func (m *SigningProposalFSM) actionPartialKeyConfirmationReceived(inEvent fsm.Ev return } -func (m *SigningProposalFSM) actionValidateSigningPartialKeyAwaitConfirmations(inEvent fsm.Event, args ...interface{}) (outEvent fsm.Event, response interface{}, err error) { +func (m *SigningProposalFSM) actionValidateSigningPartialSignsAwaitConfirmations(inEvent fsm.Event, args ...interface{}) (outEvent fsm.Event, response interface{}, err error) { var ( isContainsError bool ) @@ -256,7 +256,7 @@ func (m *SigningProposalFSM) actionValidateSigningPartialKeyAwaitConfirmations(i defer m.payloadMu.Unlock() if m.payload.SigningProposalPayload.IsExpired() { - outEvent = eventSigningPartialKeyCancelByTimeoutInternal + outEvent = eventSigningPartialSignsAwaitCancelByTimeoutInternal return } @@ -264,13 +264,13 @@ func (m *SigningProposalFSM) actionValidateSigningPartialKeyAwaitConfirmations(i for _, participant := range m.payload.SigningProposalPayload.Quorum { if participant.Status == internal.SigningError { isContainsError = true - } else if participant.Status == internal.SigningPartialKeysConfirmed { + } else if participant.Status == internal.SigningPartialSignsConfirmed { unconfirmedParticipants-- } } if isContainsError { - outEvent = eventSigningPartialKeyCancelByErrorInternal + outEvent = eventSigningPartialSignsAwaitCancelByErrorInternal return } @@ -279,7 +279,7 @@ func (m *SigningProposalFSM) actionValidateSigningPartialKeyAwaitConfirmations(i return } - outEvent = eventSigningPartialKeysConfirmedInternal + outEvent = eventSigningPartialSignsConfirmedInternal for _, participant := range m.payload.SigningProposalPayload.Quorum { participant.Status = internal.SigningProcess @@ -341,11 +341,11 @@ func (m *SigningProposalFSM) actionConfirmationError(inEvent fsm.Event, args ... // TODO: Move to methods switch inEvent { - case EventSigningPartialKeyError: + case EventSigningPartialSignError: switch signingProposalParticipant.Status { - case internal.SigningAwaitPartialKeys: + case internal.SigningAwaitPartialSigns: signingProposalParticipant.Status = internal.SigningError - case internal.SigningPartialKeysConfirmed: + case internal.SigningPartialSignsConfirmed: err = errors.New("{Status} already confirmed") case internal.SigningError: err = errors.New(fmt.Sprintf("{Status} already has {\"%s\"}", internal.SigningError)) diff --git a/fsm/state_machines/signing_proposal_fsm/init.go b/fsm/state_machines/signing_proposal_fsm/init.go index 67c0ed0..ae93a74 100644 --- a/fsm/state_machines/signing_proposal_fsm/init.go +++ b/fsm/state_machines/signing_proposal_fsm/init.go @@ -21,12 +21,12 @@ const ( StateSigningConfirmationsAwaitCancelledByTimeout = fsm.State("state_signing_confirmations_await_cancelled_by_timeout") StateSigningConfirmationsAwaitCancelledByParticipant = fsm.State("state_signing_confirmations_await_cancelled_by_participant") - StateSigningAwaitPartialKeys = fsm.State("state_signing_await_partial_keys") + StateSigningAwaitPartialSigns = fsm.State("state_signing_await_partial_signs") // Cancelled - StateSigningPartialKeysAwaitCancelledByTimeout = fsm.State("state_signing_partial_signatures_await_cancelled_by_timeout") - StateSigningPartialKeysAwaitCancelledByError = fsm.State("state_signing_partial_signatures_await_cancelled_by_error") + StateSigningPartialSignsAwaitCancelledByTimeout = fsm.State("state_signing_partial_signs_await_cancelled_by_timeout") + StateSigningPartialSignsAwaitCancelledByError = fsm.State("state_signing_partial_signs_await_cancelled_by_error") - StateSigningPartialKeysCollected = fsm.State("state_signing_partial_signatures_collected") + StateSigningPartialSignsCollected = fsm.State("state_signing_partial_signs_collected") // Events @@ -40,15 +40,15 @@ const ( eventAutoSigningValidateProposalInternal = fsm.Event("event_signing_proposal_await_validate") eventSetProposalValidatedInternal = fsm.Event("event_signing_proposal_set_validated") - EventSigningPartialKeyReceived = fsm.Event("event_signing_partial_key_received") - EventSigningPartialKeyError = fsm.Event("event_signing_partial_key_error_received") - eventSigningPartialKeyCancelByTimeoutInternal = fsm.Event("event_signing_partial_key_canceled_by_timeout_internal") - eventSigningPartialKeyCancelByErrorInternal = fsm.Event("event_signing_partial_key_canceled_by_error_internal") + EventSigningPartialSignReceived = fsm.Event("event_signing_partial_sign_received") + EventSigningPartialSignError = fsm.Event("event_signing_partial_sign_error_received") + eventSigningPartialSignsAwaitCancelByTimeoutInternal = fsm.Event("event_signing_partial_signs_await_cancel_by_timeout_internal") + eventSigningPartialSignsAwaitCancelByErrorInternal = fsm.Event("event_signing_partial_signs_await_sign_cancel_by_error_internal") - eventAutoSigningValidatePartialKeyInternal = fsm.Event("event_signing_partial_keys_await_validate") + eventAutoSigningValidatePartialSignInternal = fsm.Event("event_signing_partial_signs_await_validate") - eventSigningPartialKeysConfirmedInternal = fsm.Event("event_signing_partial_keys_confirmed_internal") - EventSigningRestart = fsm.Event("event_signing_restart") + eventSigningPartialSignsConfirmedInternal = fsm.Event("event_signing_partial_signs_confirmed_internal") + EventSigningRestart = fsm.Event("event_signing_restart") ) type SigningProposalFSM struct { @@ -81,31 +81,31 @@ func New() internal.DumpedMachineProvider { // Validate {Name: eventAutoSigningValidateProposalInternal, SrcState: []fsm.State{StateSigningAwaitConfirmations}, DstState: StateSigningAwaitConfirmations, IsInternal: true, IsAuto: true}, - {Name: eventSetProposalValidatedInternal, SrcState: []fsm.State{StateSigningAwaitConfirmations}, DstState: StateSigningAwaitPartialKeys, IsInternal: true}, + {Name: eventSetProposalValidatedInternal, SrcState: []fsm.State{StateSigningAwaitConfirmations}, DstState: StateSigningAwaitPartialSigns, IsInternal: true}, // Canceled - {Name: EventSigningPartialKeyReceived, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningAwaitPartialKeys}, - {Name: EventSigningPartialKeyError, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningPartialKeysAwaitCancelledByError}, - {Name: eventSigningPartialKeyCancelByTimeoutInternal, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningPartialKeysAwaitCancelledByTimeout, IsInternal: true}, - {Name: eventSigningPartialKeyCancelByErrorInternal, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningPartialKeysAwaitCancelledByError, IsInternal: true}, + {Name: EventSigningPartialSignReceived, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningAwaitPartialSigns}, + {Name: EventSigningPartialSignError, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningPartialSignsAwaitCancelledByError}, + {Name: eventSigningPartialSignsAwaitCancelByTimeoutInternal, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningPartialSignsAwaitCancelledByTimeout, IsInternal: true}, + {Name: eventSigningPartialSignsAwaitCancelByErrorInternal, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningPartialSignsAwaitCancelledByError, IsInternal: true}, // Validate - {Name: eventAutoSigningValidatePartialKeyInternal, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningAwaitPartialKeys, IsInternal: true, IsAuto: true}, + {Name: eventAutoSigningValidatePartialSignInternal, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningAwaitPartialSigns, IsInternal: true, IsAuto: true}, - {Name: eventSigningPartialKeysConfirmedInternal, SrcState: []fsm.State{StateSigningAwaitPartialKeys}, DstState: StateSigningPartialKeysCollected, IsInternal: true}, + {Name: eventSigningPartialSignsConfirmedInternal, SrcState: []fsm.State{StateSigningAwaitPartialSigns}, DstState: StateSigningPartialSignsCollected, IsInternal: true}, - {Name: EventSigningRestart, SrcState: []fsm.State{StateSigningPartialKeysCollected}, DstState: StateSigningIdle}, + {Name: EventSigningRestart, SrcState: []fsm.State{StateSigningPartialSignsCollected}, DstState: StateSigningIdle}, }, fsm.Callbacks{ - EventSigningInit: machine.actionInitSigningProposal, - EventSigningStart: machine.actionStartSigningProposal, - EventConfirmSigningConfirmation: machine.actionProposalResponseByParticipant, - EventDeclineSigningConfirmation: machine.actionProposalResponseByParticipant, - eventAutoSigningValidateProposalInternal: machine.actionValidateSigningProposalConfirmations, - EventSigningPartialKeyReceived: machine.actionPartialKeyConfirmationReceived, - eventAutoSigningValidatePartialKeyInternal: machine.actionValidateSigningPartialKeyAwaitConfirmations, - EventSigningPartialKeyError: machine.actionConfirmationError, - EventSigningRestart: machine.actionSigningRestart, + EventSigningInit: machine.actionInitSigningProposal, + EventSigningStart: machine.actionStartSigningProposal, + EventConfirmSigningConfirmation: machine.actionProposalResponseByParticipant, + EventDeclineSigningConfirmation: machine.actionProposalResponseByParticipant, + eventAutoSigningValidateProposalInternal: machine.actionValidateSigningProposalConfirmations, + EventSigningPartialSignReceived: machine.actionPartialSignConfirmationReceived, + eventAutoSigningValidatePartialSignInternal: machine.actionValidateSigningPartialSignsAwaitConfirmations, + EventSigningPartialSignError: machine.actionConfirmationError, + EventSigningRestart: machine.actionSigningRestart, }, ) diff --git a/fsm/types/requests/signing_proposal.go b/fsm/types/requests/signing_proposal.go index fbfaa7a..c9e94b7 100644 --- a/fsm/types/requests/signing_proposal.go +++ b/fsm/types/requests/signing_proposal.go @@ -21,7 +21,7 @@ type SigningProposalParticipantRequest struct { // States: "state_signing_await_partial_keys" // Events: "event_signing_partial_key_received" -type SigningProposalPartialKeyRequest struct { +type SigningProposalPartialSignRequest struct { SigningId string ParticipantId int PartialSign []byte diff --git a/fsm/types/requests/signing_proposal_validation.go b/fsm/types/requests/signing_proposal_validation.go index 120e44e..4ea6a97 100644 --- a/fsm/types/requests/signing_proposal_validation.go +++ b/fsm/types/requests/signing_proposal_validation.go @@ -34,7 +34,7 @@ func (r *SigningProposalParticipantRequest) Validate() error { return nil } -func (r *SigningProposalPartialKeyRequest) Validate() error { +func (r *SigningProposalPartialSignRequest) Validate() error { if r.SigningId == "" { return errors.New("{SigningId} cannot be empty") } diff --git a/fsm/types/responses/signature_proposal.go b/fsm/types/responses/signature_proposal.go index 8c517b7..c99ab3d 100644 --- a/fsm/types/responses/signature_proposal.go +++ b/fsm/types/responses/signature_proposal.go @@ -9,7 +9,8 @@ type SignatureProposalParticipantInvitationsResponse []*SignatureProposalPartici type SignatureProposalParticipantInvitationEntry struct { ParticipantId int // Public title for address, such as name, nickname, organization - Addr string + Addr string + Threshold int } // Public lists for proposal confirmation process