diff --git a/fsm.go b/fsm.go
index 163e0eccd..5c37020d2 100644
--- a/fsm.go
+++ b/fsm.go
@@ -28,9 +28,9 @@ func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface
 	}, nil
 }
 
-var fsmPlanners = []func(events []statemachine.Event, state *SectorInfo) error {
+var fsmPlanners = []func(events []statemachine.Event, state *SectorInfo) error{
 	api.UndefinedSectorState: planOne(on(SectorStart{}, api.Packing)),
-	api.Packing: planOne(on(SectorPacked{}, api.Unsealed)),
+	api.Packing:              planOne(on(SectorPacked{}, api.Unsealed)),
 	api.Unsealed: planOne(
 		on(SectorSealed{}, api.PreCommitting),
 		on(SectorSealFailed{}, api.SealFailed),
diff --git a/fsm_events.go b/fsm_events.go
index a33861d42..ddab56451 100644
--- a/fsm_events.go
+++ b/fsm_events.go
@@ -19,9 +19,11 @@ type globalMutator interface {
 // Global events
 
 type SectorRestart struct{}
+
 func (evt SectorRestart) applyGlobal(*SectorInfo) bool { return false }
 
 type SectorFatalError struct{ error }
+
 func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
 	log.Errorf("Fatal error on sector %d: %+v", state.SectorID, evt.error)
 	// TODO: Do we want to mark the state as unrecoverable?
@@ -33,6 +35,7 @@ func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
 type SectorForceState struct {
 	state api.SectorState
 }
+
 func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
 	state.State = evt.state
 	return true
@@ -44,12 +47,14 @@ type SectorStart struct {
 	id     uint64
 	pieces []Piece
 }
+
 func (evt SectorStart) apply(state *SectorInfo) {
 	state.SectorID = evt.id
 	state.Pieces = evt.pieces
 }
 
 type SectorPacked struct{ pieces []Piece }
+
 func (evt SectorPacked) apply(state *SectorInfo) {
 	state.Pieces = append(state.Pieces, evt.pieces...)
 }
@@ -59,6 +64,7 @@ type SectorSealed struct {
 	commD  []byte
 	ticket SealTicket
 }
+
 func (evt SectorSealed) apply(state *SectorInfo) {
 	state.CommD = evt.commD
 	state.CommR = evt.commR
@@ -66,14 +72,17 @@ func (evt SectorSealed) apply(state *SectorInfo) {
 }
 
 type SectorSealFailed struct{ error }
+
 func (evt SectorSealFailed) apply(*SectorInfo) {}
 
 type SectorPreCommitFailed struct{ error }
+
 func (evt SectorPreCommitFailed) apply(*SectorInfo) {}
 
 type SectorPreCommitted struct {
 	message cid.Cid
 }
+
 func (evt SectorPreCommitted) apply(state *SectorInfo) {
 	state.PreCommitMessage = &evt.message
 }
@@ -81,6 +90,7 @@ func (evt SectorPreCommitted) apply(state *SectorInfo) {
 type SectorSeedReady struct {
 	seed SealSeed
 }
+
 func (evt SectorSeedReady) apply(state *SectorInfo) {
 	state.Seed = evt.seed
 }
@@ -91,18 +101,22 @@ type SectorCommitted struct {
 	message cid.Cid
 	proof   []byte
 }
+
 func (evt SectorCommitted) apply(state *SectorInfo) {
 	state.Proof = evt.proof
 	state.CommitMessage = &evt.message
 }
 
 type SectorProving struct{}
+
 func (evt SectorProving) apply(*SectorInfo) {}
 
 type SectorFaulty struct{}
+
 func (evt SectorFaulty) apply(state *SectorInfo) {}
 
 type SectorFaultReported struct{ reportMsg cid.Cid }
+
 func (evt SectorFaultReported) apply(state *SectorInfo) {
 	state.FaultReportMsg = &evt.reportMsg
 }
diff --git a/fsm_test.go b/fsm_test.go
index fb31f5192..a76a547dc 100644
--- a/fsm_test.go
+++ b/fsm_test.go
@@ -72,12 +72,12 @@ func TestSeedRevert(t *testing.T) {
 	m.planSingle(SectorSeedReady{})
 	require.Equal(m.t, m.state.State, api.Committing)
 
-	_, err := m.s.plan([]statemachine.Event{{SectorSeedReady{seed:SealSeed{BlockHeight: 5,}}}, {SectorCommitted{}}}, m.state)
+	_, err := m.s.plan([]statemachine.Event{{SectorSeedReady{seed: SealSeed{BlockHeight: 5}}}, {SectorCommitted{}}}, m.state)
 	require.NoError(t, err)
 	require.Equal(m.t, m.state.State, api.Committing)
 
 	// not changing the seed this time
-	_, err = m.s.plan([]statemachine.Event{{SectorSeedReady{seed:SealSeed{BlockHeight: 5,}}}, {SectorCommitted{}}}, m.state)
+	_, err = m.s.plan([]statemachine.Event{{SectorSeedReady{seed: SealSeed{BlockHeight: 5}}}, {SectorCommitted{}}}, m.state)
 	require.Equal(m.t, m.state.State, api.CommitWait)
 
 	m.planSingle(SectorProving{})
diff --git a/sealing.go b/sealing.go
index f0c2b3d50..45e3d6451 100644
--- a/sealing.go
+++ b/sealing.go
@@ -66,13 +66,13 @@ type Sealing struct {
 
 func New(api sealingApi, events *events.Events, maddr address.Address, worker address.Address, ds datastore.Batching, sb sectorbuilder.Interface, tktFn TicketFn) *Sealing {
 	s := &Sealing{
-		api:            api,
+		api:    api,
 		events: events,
 
-		maddr:          maddr,
-		worker:         worker,
-		sb:             sb,
-		tktFn:          tktFn,
+		maddr:  maddr,
+		worker: worker,
+		sb:     sb,
+		tktFn:  tktFn,
 	}
 
 	s.sectors = statemachine.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix)), s, SectorInfo{})
@@ -133,4 +133,3 @@ func (m *Sealing) newSector(ctx context.Context, sid uint64, dealID uint64, ppi
 		},
 	})
 }
-