diff --git a/cmd/lotus-storage-miner/info.go b/cmd/lotus-storage-miner/info.go
index 63e57111b..79b2ba3ea 100644
--- a/cmd/lotus-storage-miner/info.go
+++ b/cmd/lotus-storage-miner/info.go
@@ -247,6 +247,7 @@ var stateList = []stateMeta{
 	{col: color.FgYellow, state: sealing.PreCommitWait},
 	{col: color.FgYellow, state: sealing.WaitSeed},
 	{col: color.FgYellow, state: sealing.Committing},
+	{col: color.FgYellow, state: sealing.SubmitCommit},
 	{col: color.FgYellow, state: sealing.CommitWait},
 	{col: color.FgYellow, state: sealing.FinalizeSector},
 
diff --git a/extern/storage-sealing/fsm.go b/extern/storage-sealing/fsm.go
index 1612cafb7..d8c7430a2 100644
--- a/extern/storage-sealing/fsm.go
+++ b/extern/storage-sealing/fsm.go
@@ -71,6 +71,10 @@ var fsmPlanners = map[SectorState]func(events []statemachine.Event, state *Secto
 		on(SectorChainPreCommitFailed{}, PreCommitFailed),
 	),
 	Committing: planCommitting,
+	SubmitCommit: planOne(
+		on(SectorCommitSubmitted{}, CommitWait),
+		on(SectorCommitFailed{}, CommitFailed),
+	),
 	CommitWait: planOne(
 		on(SectorProving{}, FinalizeSector),
 		on(SectorCommitFailed{}, CommitFailed),
@@ -182,47 +186,50 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta
 
 	/*
 
-			*   Empty <- incoming deals
-			|   |
-			|   v
-		    *<- WaitDeals <- incoming deals
-			|   |
-			|   v
-			*<- Packing <- incoming committed capacity
-			|   |
-			|   v
-			*<- PreCommit1 <--> SealPreCommit1Failed
-			|   |       ^          ^^
-			|   |       *----------++----\
-			|   v       v          ||    |
-			*<- PreCommit2 --------++--> SealPreCommit2Failed
-			|   |                  ||
-			|   v          /-------/|
-			*   PreCommitting <-----+---> PreCommitFailed
-			|   |                   |     ^
-			|   v                   |     |
-			*<- WaitSeed -----------+-----/
-			|   |||  ^              |
-			|   |||  \--------*-----/
-			|   |||           |
-			|   vvv      v----+----> ComputeProofFailed
-			*<- Committing    |
-			|   |        ^--> CommitFailed
-			|   v             ^
-			*<- CommitWait ---/
-			|   |
-			|   v
-			|   FinalizeSector <--> FinalizeFailed
-			|   |
-			|   v
-			*<- Proving
-			|
-			v
-			FailedUnrecoverable
+				*   Empty <- incoming deals
+				|   |
+				|   v
+			    *<- WaitDeals <- incoming deals
+				|   |
+				|   v
+				*<- Packing <- incoming committed capacity
+				|   |
+				|   v
+				*<- PreCommit1 <--> SealPreCommit1Failed
+				|   |       ^          ^^
+				|   |       *----------++----\
+				|   v       v          ||    |
+				*<- PreCommit2 --------++--> SealPreCommit2Failed
+				|   |                  ||
+				|   v          /-------/|
+				*   PreCommitting <-----+---> PreCommitFailed
+				|   |                   |     ^
+				|   v                   |     |
+				*<- WaitSeed -----------+-----/
+				|   |||  ^              |
+				|   |||  \--------*-----/
+				|   |||           |
+				|   vvv      v----+----> ComputeProofFailed
+				*<- Committing    |
+				|   |        ^--> CommitFailed
+				|   v             ^
+		        |   SubmitCommit  |
+		        |   |             |
+		        |   v             |
+				*<- CommitWait ---/
+				|   |
+				|   v
+				|   FinalizeSector <--> FinalizeFailed
+				|   |
+				|   v
+				*<- Proving
+				|
+				v
+				FailedUnrecoverable
 
-			UndefinedSectorState <- ¯\_(ツ)_/¯
-				|                     ^
-				*---------------------/
+				UndefinedSectorState <- ¯\_(ツ)_/¯
+					|                     ^
+					*---------------------/
 
 	*/
 
@@ -248,6 +255,8 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta
 		return m.handleWaitSeed, processed, nil
 	case Committing:
 		return m.handleCommitting, processed, nil
+	case SubmitCommit:
+		return m.handleSubmitCommit, processed, nil
 	case CommitWait:
 		return m.handleCommitWait, processed, nil
 	case FinalizeSector:
@@ -294,24 +303,25 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta
 }
 
 func planCommitting(events []statemachine.Event, state *SectorInfo) (uint64, error) {
-	for _, event := range events {
+	for i, event := range events {
 		switch e := event.User.(type) {
 		case globalMutator:
 			if e.applyGlobal(state) {
-				return 1, nil
+				return uint64(i + 1), nil
 			}
 		case SectorCommitted: // the normal case
 			e.apply(state)
-			state.State = CommitWait
+			state.State = SubmitCommit
 		case SectorSeedReady: // seed changed :/
 			if e.SeedEpoch == state.SeedEpoch && bytes.Equal(e.SeedValue, state.SeedValue) {
 				log.Warnf("planCommitting: got SectorSeedReady, but the seed didn't change")
 				continue // or it didn't!
 			}
+
 			log.Warnf("planCommitting: commit Seed changed")
 			e.apply(state)
 			state.State = Committing
-			return 1, nil
+			return uint64(i + 1), nil
 		case SectorComputeProofFailed:
 			state.State = ComputeProofFailed
 		case SectorSealPreCommit1Failed:
@@ -321,10 +331,10 @@ func planCommitting(events []statemachine.Event, state *SectorInfo) (uint64, err
 		case SectorRetryCommitWait:
 			state.State = CommitWait
 		default:
-			return 0, xerrors.Errorf("planCommitting got event of unknown type %T, events: %+v", event.User, events)
+			return uint64(i), xerrors.Errorf("planCommitting got event of unknown type %T, events: %+v", event.User, events)
 		}
 	}
-	return 1, nil
+	return uint64(len(events)), nil
 }
 
 func (m *Sealing) restartSectors(ctx context.Context) error {
diff --git a/extern/storage-sealing/fsm_events.go b/extern/storage-sealing/fsm_events.go
index 06f4b7b2c..29a52f362 100644
--- a/extern/storage-sealing/fsm_events.go
+++ b/extern/storage-sealing/fsm_events.go
@@ -192,12 +192,18 @@ func (evt SectorCommitFailed) FormatError(xerrors.Printer) (next error) { return
 func (evt SectorCommitFailed) apply(*SectorInfo)                        {}
 
 type SectorCommitted struct {
-	Message cid.Cid
-	Proof   []byte
+	Proof []byte
 }
 
 func (evt SectorCommitted) apply(state *SectorInfo) {
 	state.Proof = evt.Proof
+}
+
+type SectorCommitSubmitted struct {
+	Message cid.Cid
+}
+
+func (evt SectorCommitSubmitted) apply(state *SectorInfo) {
 	state.CommitMessage = &evt.Message
 }
 
diff --git a/extern/storage-sealing/sector_state.go b/extern/storage-sealing/sector_state.go
index 2f57d83e8..f3106ea3b 100644
--- a/extern/storage-sealing/sector_state.go
+++ b/extern/storage-sealing/sector_state.go
@@ -10,12 +10,13 @@ const (
 	WaitDeals      SectorState = "WaitDeals"     // waiting for more pieces (deals) to be added to the sector
 	Packing        SectorState = "Packing"       // sector not in sealStore, and not on chain
 	PreCommit1     SectorState = "PreCommit1"    // do PreCommit1
-	PreCommit2     SectorState = "PreCommit2"    // do PreCommit1
+	PreCommit2     SectorState = "PreCommit2"    // do PreCommit2
 	PreCommitting  SectorState = "PreCommitting" // on chain pre-commit
 	PreCommitWait  SectorState = "PreCommitWait" // waiting for precommit to land on chain
 	WaitSeed       SectorState = "WaitSeed"      // waiting for seed
-	Committing     SectorState = "Committing"
-	CommitWait     SectorState = "CommitWait" // waiting for message to land on chain
+	Committing     SectorState = "Committing"    // compute PoRep
+	SubmitCommit   SectorState = "SubmitCommit"  // send commit message to the chain
+	CommitWait     SectorState = "CommitWait"    // wait for the commit message to land on chain
 	FinalizeSector SectorState = "FinalizeSector"
 	Proving        SectorState = "Proving"
 	// error modes
diff --git a/extern/storage-sealing/states_sealing.go b/extern/storage-sealing/states_sealing.go
index a434d1fcb..4dfec6b52 100644
--- a/extern/storage-sealing/states_sealing.go
+++ b/extern/storage-sealing/states_sealing.go
@@ -326,21 +326,25 @@ func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo)
 		return ctx.Send(SectorComputeProofFailed{xerrors.Errorf("computing seal proof failed(2): %w", err)})
 	}
 
+	return ctx.Send(SectorCommitted{
+		Proof: proof,
+	})
+}
+
+func (m *Sealing) handleSubmitCommit(ctx statemachine.Context, sector SectorInfo) error {
 	tok, _, err := m.api.ChainHead(ctx.Context())
 	if err != nil {
 		log.Errorf("handleCommitting: api error, not proceeding: %+v", err)
 		return nil
 	}
 
-	if err := m.checkCommit(ctx.Context(), sector, proof, tok); err != nil {
+	if err := m.checkCommit(ctx.Context(), sector, sector.Proof, tok); err != nil {
 		return ctx.Send(SectorCommitFailed{xerrors.Errorf("commit check error: %w", err)})
 	}
 
-	// TODO: Consider splitting states and persist proof for faster recovery
-
 	params := &miner.ProveCommitSectorParams{
 		SectorNumber: sector.SectorNumber,
-		Proof:        proof,
+		Proof:        sector.Proof,
 	}
 
 	enc := new(bytes.Buffer)
@@ -372,14 +376,13 @@ func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo)
 		collateral = big.Zero()
 	}
 
-	// TODO: check seed / ticket are up to date
+	// TODO: check seed / ticket / deals are up to date
 	mcid, err := m.api.SendMsg(ctx.Context(), waddr, m.maddr, builtin.MethodsMiner.ProveCommitSector, collateral, m.feeCfg.MaxCommitGasFee, enc.Bytes())
 	if err != nil {
 		return ctx.Send(SectorCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)})
 	}
 
-	return ctx.Send(SectorCommitted{
-		Proof:   proof,
+	return ctx.Send(SectorCommitSubmitted{
 		Message: mcid,
 	})
 }