supplycommit: add logic to resend trigger event for select states

In this commit, we add logic to resend trigger events for select states.
Along the way, we modify the way the state machine works: we can avoid
having to extract the PSBT again, just by reading it from the state
transition.

Author: Roasbeef

universe/supplycommit/multi_sm_manager.go

@@ -160,8 +160,15 @@ func (m *MultiStateMachineManager) fetchStateMachine(
 		ChainParams:      m.cfg.ChainParams,
 	}
 
-	// TODO(ffranr): Get initial state from disk here.
-	initialState := &DefaultState{}
+	// Before we start the state machine, we'll need to fetch the current
+	// state from disk, to see if we need to emit any new events.
+	ctx, cancel := m.WithCtxQuitNoTimeout()
+	defer cancel()
+
+	initialState, _, err := m.cfg.StateLog.FetchState(ctx, assetSpec)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch current state: %w", err)
+	}
 
 	// Create a new error reporter for the state machine.
 	errorReporter := NewErrorReporter(assetSpec)
@@ -180,6 +187,23 @@ func (m *MultiStateMachineManager) fetchStateMachine(
 	smCtx, _ := m.WithCtxQuitNoTimeout()
 	newSm.Start(smCtx)
 
+	// If specific initial states are provided, we send the corresponding
+	// events to the state machine to ensure it begins ticking as expected.
+	switch initialState.(type) {
+	// Once we write the commitment transaction to disk in CommitTxSign,
+	// then on restart, we'll be in the broadcast state. From this point,
+	// we'll trigger the broadcast event so we can resume the state machine.
+	case *CommitBroadcastState:
+		newSm.SendEvent(ctx, &BroadcastEvent{})
+
+	// Once we get a confirmation, then we'll transition to the
+	// CommitFinalizeState. If we crashed right after that, then
+	// we'll also send the finalize event so we can apply
+	// everything, and transition back to the normal default state.
+	case *CommitFinalizeState:
+		newSm.SendEvent(ctx, &FinalizeEvent{})
+	}
+
 	m.smCache.Set(*groupKey, &newSm)
 
 	return &newSm, nil

universe/supplycommit/transitions.go

@@ -630,9 +630,7 @@ func (c *CommitTxSignState) ProcessEvent(event Event,
 				SupplyTransition: stateTransition,
 			},
 			NewEvents: lfn.Some(FsmEvent{
-				InternalEvent: []Event{&BroadcastEvent{
-					SignedCommitPkt: signedPsbt,
-				}},
+				InternalEvent: []Event{&BroadcastEvent{}},
 			}),
 		}, nil
 
@@ -654,14 +652,12 @@ func (c *CommitBroadcastState) ProcessEvent(event Event,
 	// signed commit tx, then register for a confirmation for when it
 	// confirms.
 	case *BroadcastEvent:
-		// First, we'll extract the final signed transaction from the
-		// PSBT.
-		commitTx, err := psbt.Extract(newEvent.SignedCommitPkt)
-		if err != nil {
-			return nil, fmt.Errorf("unable to extract "+
-				"psbt: %w", err)
+		if c.SupplyTransition.NewCommitment.Txn == nil {
+			return nil, fmt.Errorf("commitment transaction is nil")
 		}
 
+		commitTx := c.SupplyTransition.NewCommitment.Txn
+
 		// Construct a detailed label for the broadcast request using
 		// the helper function.
 		label := createCommitmentTxLabel(