Merge pull request #7835 from filecoin-project/bloxico/system-test-matrix

misc: api: Annotate lotus tests according to listed behaviors

chain/messagepool/messagepool_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package messagepool
 
 import (
@@ -206,6 +207,7 @@ func (tma *testMpoolAPI) ChainComputeBaseFee(ctx context.Context, ts *types.TipS
 
 func assertNonce(t *testing.T, mp *MessagePool, addr address.Address, val uint64) {
 	t.Helper()
+	//stm: @CHAIN_MEMPOOL_GET_NONCE_001
 	n, err := mp.GetNonce(context.TODO(), addr, types.EmptyTSK)
 	if err != nil {
 		t.Fatal(err)
@@ -366,8 +368,10 @@ func TestMessagePoolMessagesInEachBlock(t *testing.T) {
 	tma.applyBlock(t, a)
 	tsa := mock.TipSet(a)
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	_, _ = mp.Pending(context.TODO())
 
+	//stm: @CHAIN_MEMPOOL_SELECT_001
 	selm, _ := mp.SelectMessages(context.Background(), tsa, 1)
 	if len(selm) == 0 {
 		t.Fatal("should have returned the rest of the messages")
@@ -428,6 +432,7 @@ func TestRevertMessages(t *testing.T) {
 
 	assertNonce(t, mp, sender, 4)
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	p, _ := mp.Pending(context.TODO())
 	fmt.Printf("%+v\n", p)
 	if len(p) != 3 {
@@ -486,6 +491,7 @@ func TestPruningSimple(t *testing.T) {
 
 	mp.Prune()
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	msgs, _ := mp.Pending(context.TODO())
 	if len(msgs) != 5 {
 		t.Fatal("expected only 5 messages in pool, got: ", len(msgs))
@@ -528,6 +534,7 @@ func TestLoadLocal(t *testing.T) {
 	msgs := make(map[cid.Cid]struct{})
 	for i := 0; i < 10; i++ {
 		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		//stm: @CHAIN_MEMPOOL_PUSH_001
 		cid, err := mp.Push(context.TODO(), m)
 		if err != nil {
 			t.Fatal(err)
@@ -544,6 +551,7 @@ func TestLoadLocal(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	pmsgs, _ := mp.Pending(context.TODO())
 	if len(msgs) != len(pmsgs) {
 		t.Fatalf("expected %d messages, but got %d", len(msgs), len(pmsgs))
@@ -599,6 +607,7 @@ func TestClearAll(t *testing.T) {
 	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin2.StorageMarketActorCodeID, M: 2}]
 	for i := 0; i < 10; i++ {
 		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		//stm: @CHAIN_MEMPOOL_PUSH_001
 		_, err := mp.Push(context.TODO(), m)
 		if err != nil {
 			t.Fatal(err)
@@ -610,8 +619,10 @@ func TestClearAll(t *testing.T) {
 		mustAdd(t, mp, m)
 	}
 
+	//stm: @CHAIN_MEMPOOL_CLEAR_001
 	mp.Clear(context.Background(), true)
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	pending, _ := mp.Pending(context.TODO())
 	if len(pending) > 0 {
 		t.Fatalf("cleared the mpool, but got %d pending messages", len(pending))
@@ -654,6 +665,7 @@ func TestClearNonLocal(t *testing.T) {
 	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin2.StorageMarketActorCodeID, M: 2}]
 	for i := 0; i < 10; i++ {
 		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		//stm: @CHAIN_MEMPOOL_PUSH_001
 		_, err := mp.Push(context.TODO(), m)
 		if err != nil {
 			t.Fatal(err)
@@ -665,8 +677,10 @@ func TestClearNonLocal(t *testing.T) {
 		mustAdd(t, mp, m)
 	}
 
+	//stm: @CHAIN_MEMPOOL_CLEAR_001
 	mp.Clear(context.Background(), false)
 
+	//stm: @CHAIN_MEMPOOL_PENDING_001
 	pending, _ := mp.Pending(context.TODO())
 	if len(pending) != 10 {
 		t.Fatalf("expected 10 pending messages, but got %d instead", len(pending))
@@ -724,6 +738,7 @@ func TestUpdates(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		//stm: @CHAIN_MEMPOOL_PUSH_001
 		_, err := mp.Push(context.TODO(), m)
 		if err != nil {
 			t.Fatal(err)

chain/messagesigner/messagesigner_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package messagesigner
 
 import (
@@ -60,6 +61,7 @@ func TestMessageSignerSignMessage(t *testing.T) {
 	to2, err := w.WalletNew(ctx, types.KTSecp256k1)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_MESSAGE_SIGNER_NEW_SIGNER_001, @CHAIN_MESSAGE_SIGNER_SIGN_MESSAGE_001, @CHAIN_MESSAGE_SIGNER_SIGN_MESSAGE_005
 	type msgSpec struct {
 		msg        *types.Message
 		mpoolNonce [1]uint64

chain/rand/rand_test.go

@@ -1,3 +1,4 @@
+//stm:#unit
 package rand_test
 
 import (
@@ -55,11 +56,13 @@ func TestNullRandomnessV1(t *testing.T) {
 
 	randEpoch := ts.TipSet.TipSet().Height() - 2
 
+	//stm: @BLOCKCHAIN_RAND_GET_BEACON_RANDOMNESS_V1_01, @BLOCKCHAIN_RAND_EXTRACT_BEACON_ENTRY_FOR_EPOCH_01, @BLOCKCHAIN_RAND_GET_BEACON_RANDOMNESS_TIPSET_02
 	rand1, err := cg.StateManager().GetRandomnessFromBeacon(ctx, pers, randEpoch, entropy, ts.TipSet.TipSet().Key())
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	//stm: @BLOCKCHAIN_BEACON_GET_BEACON_FOR_EPOCH_01
 	bch := cg.BeaconSchedule().BeaconForEpoch(randEpoch).Entry(ctx, uint64(beforeNullHeight)+offset)
 
 	select {
@@ -68,6 +71,7 @@ func TestNullRandomnessV1(t *testing.T) {
 			t.Fatal(resp.Err)
 		}
 
+		//stm: @BLOCKCHAIN_RAND_DRAW_RANDOMNESS_01
 		rand2, err := rand.DrawRandomness(resp.Entry.Data, pers, randEpoch, entropy)
 		if err != nil {
 			t.Fatal(err)
@@ -131,11 +135,13 @@ func TestNullRandomnessV2(t *testing.T) {
 
 	randEpoch := ts.TipSet.TipSet().Height() - 2
 
+	//stm: @BLOCKCHAIN_RAND_GET_BEACON_RANDOMNESS_V2_01
 	rand1, err := cg.StateManager().GetRandomnessFromBeacon(ctx, pers, randEpoch, entropy, ts.TipSet.TipSet().Key())
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	//stm: @BLOCKCHAIN_BEACON_GET_BEACON_FOR_EPOCH_01
 	bch := cg.BeaconSchedule().BeaconForEpoch(randEpoch).Entry(ctx, uint64(ts.TipSet.TipSet().Height())+offset)
 
 	select {
@@ -144,6 +150,7 @@ func TestNullRandomnessV2(t *testing.T) {
 			t.Fatal(resp.Err)
 		}
 
+		//stm: @BLOCKCHAIN_RAND_DRAW_RANDOMNESS_01, @BLOCKCHAIN_RAND_EXTRACT_BEACON_ENTRY_FOR_EPOCH_01, @BLOCKCHAIN_RAND_GET_BEACON_RANDOMNESS_TIPSET_03
 		// note that the randEpoch passed to DrawRandomness is still randEpoch (not the latest ts height)
 		rand2, err := rand.DrawRandomness(resp.Entry.Data, pers, randEpoch, entropy)
 		if err != nil {
@@ -212,11 +219,13 @@ func TestNullRandomnessV3(t *testing.T) {
 
 	randEpoch := ts.TipSet.TipSet().Height() - 2
 
+	//stm: @BLOCKCHAIN_RAND_GET_BEACON_RANDOMNESS_V3_01, @BLOCKCHAIN_RAND_EXTRACT_BEACON_ENTRY_FOR_EPOCH_01
 	rand1, err := cg.StateManager().GetRandomnessFromBeacon(ctx, pers, randEpoch, entropy, ts.TipSet.TipSet().Key())
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	//stm: @BLOCKCHAIN_BEACON_GET_BEACON_FOR_EPOCH_01
 	bch := cg.BeaconSchedule().BeaconForEpoch(randEpoch).Entry(ctx, uint64(randEpoch)+offset)
 
 	select {
@@ -225,6 +234,7 @@ func TestNullRandomnessV3(t *testing.T) {
 			t.Fatal(resp.Err)
 		}
 
+		//stm: @BLOCKCHAIN_RAND_DRAW_RANDOMNESS_01
 		rand2, err := rand.DrawRandomness(resp.Entry.Data, pers, randEpoch, entropy)
 		if err != nil {
 			t.Fatal(err)

chain/sub/incoming_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sub
 
 import (
@@ -49,6 +50,7 @@ func TestFetchCidsWithDedup(t *testing.T) {
 	}
 	g := &getter{msgs}
 
+	//stm: @CHAIN_INCOMING_FETCH_MESSAGES_BY_CID_001
 	// the cids have a duplicate
 	res, err := FetchMessagesByCids(context.TODO(), g, append(cids, cids[0]))
 

chain/sync_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package chain_test
 
 import (
@@ -462,6 +463,8 @@ func (tu *syncTestUtil) waitUntilSyncTarget(to int, target *types.TipSet) {
 }
 
 func TestSyncSimple(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 50
 	tu := prepSyncTest(t, H)
 
@@ -478,6 +481,8 @@ func TestSyncSimple(t *testing.T) {
 }
 
 func TestSyncMining(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 50
 	tu := prepSyncTest(t, H)
 
@@ -500,6 +505,8 @@ func TestSyncMining(t *testing.T) {
 }
 
 func TestSyncBadTimestamp(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 50
 	tu := prepSyncTest(t, H)
 
@@ -554,6 +561,8 @@ func (wpp badWpp) ComputeProof(context.Context, []proof7.ExtendedSectorInfo, abi
 }
 
 func TestSyncBadWinningPoSt(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 15
 	tu := prepSyncTest(t, H)
 
@@ -583,6 +592,9 @@ func (tu *syncTestUtil) loadChainToNode(to int) {
 }
 
 func TestSyncFork(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -650,6 +662,9 @@ func TestSyncFork(t *testing.T) {
 // A and B both include _different_ messages from sender X with nonce N (where N is the correct nonce for X).
 // We can confirm that the state can be correctly computed, and that `MessagesForTipset` behaves as expected.
 func TestDuplicateNonce(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -704,6 +719,7 @@ func TestDuplicateNonce(t *testing.T) {
 
 	var includedMsg cid.Cid
 	var skippedMsg cid.Cid
+	//stm: @CHAIN_STATE_SEARCH_MSG_001
 	r0, err0 := tu.nds[0].StateSearchMsg(context.TODO(), ts2.TipSet().Key(), msgs[0][0].Cid(), api.LookbackNoLimit, true)
 	r1, err1 := tu.nds[0].StateSearchMsg(context.TODO(), ts2.TipSet().Key(), msgs[1][0].Cid(), api.LookbackNoLimit, true)
 
@@ -745,6 +761,9 @@ func TestDuplicateNonce(t *testing.T) {
 // This test asserts that a block that includes a message with bad nonce can't be synced. A nonce is "bad" if it can't
 // be applied on the parent state.
 func TestBadNonce(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -792,6 +811,9 @@ func TestBadNonce(t *testing.T) {
 // One of the messages uses the sender's robust address, the other uses the ID address.
 // Such a block is invalid and should not sync.
 func TestMismatchedNoncesRobustID(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001, @CHAIN_SYNCER_STOP_001
 	v5h := abi.ChainEpoch(4)
 	tu := prepSyncTestWithV5Height(t, int(v5h+5), v5h)
 
@@ -804,6 +826,7 @@ func TestMismatchedNoncesRobustID(t *testing.T) {
 	require.NoError(t, err)
 
 	// Produce a message from the banker
+	//stm: @CHAIN_STATE_LOOKUP_ID_001
 	makeMsg := func(id bool) *types.SignedMessage {
 		sender := tu.g.Banker()
 		if id {
@@ -846,6 +869,9 @@ func TestMismatchedNoncesRobustID(t *testing.T) {
 // One of the messages uses the sender's robust address, the other uses the ID address.
 // Such a block is valid and should sync.
 func TestMatchedNoncesRobustID(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001, @CHAIN_SYNCER_STOP_001
 	v5h := abi.ChainEpoch(4)
 	tu := prepSyncTestWithV5Height(t, int(v5h+5), v5h)
 
@@ -858,6 +884,7 @@ func TestMatchedNoncesRobustID(t *testing.T) {
 	require.NoError(t, err)
 
 	// Produce a message from the banker with specified nonce
+	//stm: @CHAIN_STATE_LOOKUP_ID_001
 	makeMsg := func(n uint64, id bool) *types.SignedMessage {
 		sender := tu.g.Banker()
 		if id {
@@ -917,6 +944,8 @@ func runSyncBenchLength(b *testing.B, l int) {
 }
 
 func TestSyncInputs(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_VALIDATE_BLOCK_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -944,6 +973,9 @@ func TestSyncInputs(t *testing.T) {
 }
 
 func TestSyncCheckpointHead(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -963,6 +995,7 @@ func TestSyncCheckpointHead(t *testing.T) {
 	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil, 0, true)
 
 	tu.waitUntilSyncTarget(p1, a.TipSet())
+	//stm: @CHAIN_SYNCER_CHECKPOINT_001
 	tu.checkpointTs(p1, a.TipSet().Key())
 
 	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
@@ -982,15 +1015,20 @@ func TestSyncCheckpointHead(t *testing.T) {
 	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
 	p1Head := tu.getHead(p1)
 	require.True(tu.t, p1Head.Equals(a.TipSet()))
+	//stm: @CHAIN_SYNCER_CHECK_BAD_001
 	tu.assertBad(p1, b.TipSet())
 
 	// Should be able to switch forks.
+	//stm: @CHAIN_SYNCER_CHECKPOINT_001
 	tu.checkpointTs(p1, b.TipSet().Key())
 	p1Head = tu.getHead(p1)
 	require.True(tu.t, p1Head.Equals(b.TipSet()))
 }
 
 func TestSyncCheckpointEarlierThanHead(t *testing.T) {
+	//stm: @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01, @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_SYNC_001, @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001, @CHAIN_SYNCER_STOP_001
 	H := 10
 	tu := prepSyncTest(t, H)
 
@@ -1010,6 +1048,7 @@ func TestSyncCheckpointEarlierThanHead(t *testing.T) {
 	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil, 0, true)
 
 	tu.waitUntilSyncTarget(p1, a.TipSet())
+	//stm: @CHAIN_SYNCER_CHECKPOINT_001
 	tu.checkpointTs(p1, a1.TipSet().Key())
 
 	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
@@ -1029,15 +1068,19 @@ func TestSyncCheckpointEarlierThanHead(t *testing.T) {
 	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
 	p1Head := tu.getHead(p1)
 	require.True(tu.t, p1Head.Equals(a.TipSet()))
+	//stm: @CHAIN_SYNCER_CHECK_BAD_001
 	tu.assertBad(p1, b.TipSet())
 
 	// Should be able to switch forks.
+	//stm: @CHAIN_SYNCER_CHECKPOINT_001
 	tu.checkpointTs(p1, b.TipSet().Key())
 	p1Head = tu.getHead(p1)
 	require.True(tu.t, p1Head.Equals(b.TipSet()))
 }
 
 func TestInvalidHeight(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001, @CHAIN_SYNCER_START_001
+	//stm: @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	H := 50
 	tu := prepSyncTest(t, H)
 

extern/sector-storage/manager_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sectorstorage
 
 import (
@@ -363,6 +364,7 @@ func TestRedoPC1(t *testing.T) {
 
 // Manager restarts in the middle of a task, restarts it, it completes
 func TestRestartManager(t *testing.T) {
+	//stm: @WORKER_JOBS_001
 	test := func(returnBeforeCall bool) func(*testing.T) {
 		return func(t *testing.T) {
 			logging.SetAllLoggers(logging.LevelDebug)
@@ -507,6 +509,7 @@ func TestRestartWorker(t *testing.T) {
 	<-arch
 	require.NoError(t, w.Close())
 
+	//stm: @WORKER_STATS_001
 	for {
 		if len(m.WorkerStats()) == 0 {
 			break
@@ -569,6 +572,7 @@ func TestReenableWorker(t *testing.T) {
 	// disable
 	atomic.StoreInt64(&w.testDisable, 1)
 
+	//stm: @WORKER_STATS_001
 	for i := 0; i < 100; i++ {
 		if !m.WorkerStats()[w.session].Enabled {
 			break

extern/sector-storage/sched_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sectorstorage
 
 import (
@@ -206,6 +207,7 @@ func TestSchedStartStop(t *testing.T) {
 }
 
 func TestSched(t *testing.T) {
+	//stm: @WORKER_JOBS_001
 	storiface.ParallelNum = 1
 	storiface.ParallelDenom = 1
 

extern/sector-storage/stores/remote_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package stores_test
 
 import (
@@ -154,6 +155,7 @@ func TestMoveShared(t *testing.T) {
 }
 
 func TestReader(t *testing.T) {
+	//stm: @STORAGE_INFO_001
 	logging.SetAllLoggers(logging.LevelDebug)
 	bz := []byte("Hello World")
 

extern/storage-sealing/commit_batch_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sealing_test
 
 import (
@@ -28,6 +29,7 @@ import (
 )
 
 func TestCommitBatcher(t *testing.T) {
+	//stm: @CHAIN_STATE_MINER_PRE_COM_INFO_001, @CHAIN_STATE_MINER_INFO_001, @CHAIN_STATE_NETWORK_VERSION_001
 	t0123, err := address.NewFromString("t0123")
 	require.NoError(t, err)
 
@@ -147,6 +149,7 @@ func TestCommitBatcher(t *testing.T) {
 		}
 	}
 
+	//stm: @CHAIN_STATE_MINER_INFO_001, @CHAIN_STATE_NETWORK_VERSION_001, @CHAIN_STATE_MINER_GET_COLLATERAL_001
 	expectSend := func(expect []abi.SectorNumber, aboveBalancer, failOnePCI bool) action {
 		return func(t *testing.T, s *mocks.MockCommitBatcherApi, pcb *sealing.CommitBatcher) promise {
 			s.EXPECT().StateMinerInfo(gomock.Any(), gomock.Any(), gomock.Any()).Return(miner.MinerInfo{Owner: t0123, Worker: t0123}, nil)

extern/storage-sealing/precommit_batch_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sealing_test
 
 import (
@@ -38,6 +39,7 @@ var fc = config.MinerFeeConfig{
 }
 
 func TestPrecommitBatcher(t *testing.T) {
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	t0123, err := address.NewFromString("t0123")
 	require.NoError(t, err)
 
@@ -151,6 +153,7 @@ func TestPrecommitBatcher(t *testing.T) {
 		}
 	}
 
+	//stm: @CHAIN_STATE_MINER_INFO_001, @CHAIN_STATE_NETWORK_VERSION_001
 	expectSend := func(expect []abi.SectorNumber) action {
 		return func(t *testing.T, s *mocks.MockPreCommitBatcherApi, pcb *sealing.PreCommitBatcher) promise {
 			s.EXPECT().ChainHead(gomock.Any()).Return(nil, abi.ChainEpoch(1), nil)
@@ -171,6 +174,7 @@ func TestPrecommitBatcher(t *testing.T) {
 		}
 	}
 
+	//stm: @CHAIN_STATE_MINER_INFO_001, @CHAIN_STATE_NETWORK_VERSION_001
 	expectSendsSingle := func(expect []abi.SectorNumber) action {
 		return func(t *testing.T, s *mocks.MockPreCommitBatcherApi, pcb *sealing.PreCommitBatcher) promise {
 			s.EXPECT().ChainHead(gomock.Any()).Return(nil, abi.ChainEpoch(1), nil)

extern/storage-sealing/states_failed_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package sealing_test
 
 import (
@@ -49,6 +50,7 @@ func TestStateRecoverDealIDs(t *testing.T) {
 		PieceCID: idCid("newPieceCID"),
 	}
 
+	//stm: @CHAIN_STATE_MARKET_STORAGE_DEAL_001, @CHAIN_STATE_NETWORK_VERSION_001
 	api.EXPECT().StateMarketStorageDealProposal(ctx, dealId, nil).Return(dealProposal, nil)
 
 	pc := idCid("publishCID")

itests/api_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -19,6 +20,12 @@ import (
 )
 
 func TestAPI(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_STATE_MINER_INFO_001
 	t.Run("direct", func(t *testing.T) {
 		runAPITest(t)
 	})
@@ -116,11 +123,13 @@ func (ts *apiSuite) testSearchMsg(t *testing.T) {
 	sm, err := full.MpoolPushMessage(ctx, msg, nil)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	res, err := full.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
 	require.NoError(t, err)
 
 	require.Equal(t, exitcode.Ok, res.Receipt.ExitCode, "message not successful")
 
+	//stm: @CHAIN_STATE_SEARCH_MSG_001
 	searchRes, err := full.StateSearchMsg(ctx, types.EmptyTSK, sm.Cid(), lapi.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.NotNil(t, searchRes)

itests/ccupgrade_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -18,6 +19,15 @@ import (
 )
 
 func TestCCUpgrade(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_STATE_MINER_GET_INFO_001
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+
+	//stm: @MINER_SECTOR_LIST_001
 	kit.QuietMiningLogs()
 
 	for _, height := range []abi.ChainEpoch{
@@ -62,6 +72,7 @@ func runTestCCUpgrade(t *testing.T, upgradeHeight abi.ChainEpoch) *kit.TestFullN
 	}
 	waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
 
+	//stm: @SECTOR_CC_UPGRADE_001
 	err = miner.SectorMarkForUpgrade(ctx, sl[0], true)
 	require.NoError(t, err)
 

itests/cli_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -11,6 +12,11 @@ import (
 
 // TestClient does a basic test to exercise the client CLI commands.
 func TestClient(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	kit.QuietMiningLogs()
 

itests/deadlines_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -52,6 +53,13 @@ import (
 // * asserts that miner B loses power
 // * asserts that miner D loses power, is inactive
 func TestDeadlineToggling(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @MINER_SECTOR_LIST_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -108,6 +116,7 @@ func TestDeadlineToggling(t *testing.T) {
 	{
 		minerC.PledgeSectors(ctx, sectorsC, 0, nil)
 
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err := client.StateMinerProvingDeadline(ctx, maddrC, types.EmptyTSK)
 		require.NoError(t, err)
 
@@ -127,6 +136,7 @@ func TestDeadlineToggling(t *testing.T) {
 
 		expectedPower := types.NewInt(uint64(ssz) * sectorsC)
 
+		//stm: @CHAIN_STATE_MINER_POWER_001
 		p, err := client.StateMinerPower(ctx, maddrC, types.EmptyTSK)
 		require.NoError(t, err)
 
@@ -147,12 +157,14 @@ func TestDeadlineToggling(t *testing.T) {
 	}
 
 	checkMiner := func(ma address.Address, power abi.StoragePower, active, activeIfCron bool, tsk types.TipSetKey) {
+		//stm: @CHAIN_STATE_MINER_POWER_001
 		p, err := client.StateMinerPower(ctx, ma, tsk)
 		require.NoError(t, err)
 
 		// make sure it has the expected power.
 		require.Equal(t, p.MinerPower.RawBytePower, power)
 
+		//stm: @CHAIN_STATE_GET_ACTOR_001
 		mact, err := client.StateGetActor(ctx, ma, tsk)
 		require.NoError(t, err)
 
@@ -187,6 +199,7 @@ func TestDeadlineToggling(t *testing.T) {
 		checkMiner(maddrB, types.NewInt(0), true, true, uts.Key())
 	}
 
+	//stm: @CHAIN_STATE_NETWORK_VERSION_001
 	nv, err := client.StateNetworkVersion(ctx, types.EmptyTSK)
 	require.NoError(t, err)
 	require.GreaterOrEqual(t, nv, network.Version12)
@@ -246,6 +259,7 @@ func TestDeadlineToggling(t *testing.T) {
 		}, nil)
 		require.NoError(t, err)
 
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		r, err := client.StateWaitMsg(ctx, m.Cid(), 2, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)
@@ -298,6 +312,7 @@ func TestDeadlineToggling(t *testing.T) {
 			sectorbit := bitfield.New()
 			sectorbit.Set(uint64(sectorNum))
 
+			//stm: @CHAIN_STATE_SECTOR_PARTITION_001
 			loca, err := client.StateSectorPartition(ctx, maddrD, sectorNum, types.EmptyTSK)
 			require.NoError(t, err)
 
@@ -329,6 +344,7 @@ func TestDeadlineToggling(t *testing.T) {
 
 		t.Log("sent termination message:", smsg.Cid())
 
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		r, err := client.StateWaitMsg(ctx, smsg.Cid(), 2, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)

itests/deals_512mb_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -12,6 +13,13 @@ import (
 )
 
 func TestStorageDealMissingBlock(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	ctx := context.Background()
 
 	// enable 512MiB proofs so we can conduct larger transfers.

itests/deals_concurrent_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -71,6 +72,12 @@ func TestDealWithMarketAndMinerNode(t *testing.T) {
 }
 
 func TestDealCyclesConcurrent(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}

itests/deals_max_staging_deals_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -12,6 +13,13 @@ import (
 )
 
 func TestMaxStagingDeals(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	ctx := context.Background()
 
 	// enable 512MiB proofs so we can conduct larger transfers.

itests/deals_offline_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -16,7 +17,13 @@ import (
 )
 
 func TestOfflineDealFlow(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_DATA_CALCULATE_COMMP_001, @CLIENT_DATA_GENERATE_CAR_001, @CLIENT_DATA_GET_DEAL_PIECE_CID_001, @CLIENT_DATA_GET_DEAL_PIECE_CID_001
 	runTest := func(t *testing.T, fastRet bool, upscale abi.PaddedPieceSize) {
 		ctx := context.Background()
 		client, miner, ens := kit.EnsembleMinimal(t, kit.WithAllSubsystems()) // no mock proofs
@@ -60,6 +67,7 @@ func TestOfflineDealFlow(t *testing.T) {
 
 		proposalCid := dh.StartDeal(ctx, dp)
 
+		//stm: @CLIENT_STORAGE_DEALS_GET_001
 		// Wait for the deal to reach StorageDealCheckForAcceptance on the client
 		cd, err := client.ClientGetDealInfo(ctx, *proposalCid)
 		require.NoError(t, err)

itests/deals_padding_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -14,7 +15,13 @@ import (
 )
 
 func TestDealPadding(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_DATA_GET_DEAL_PIECE_CID_001
 	kit.QuietMiningLogs()
 
 	var blockTime = 250 * time.Millisecond
@@ -58,6 +65,7 @@ func TestDealPadding(t *testing.T) {
 		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 		time.Sleep(time.Second)
 
+		//stm: @CLIENT_STORAGE_DEALS_GET_001
 		di, err := client.ClientGetDealInfo(ctx, *proposalCid)
 		require.NoError(t, err)
 		require.True(t, di.PieceCID.Equals(pcid))

itests/deals_partial_retrieval_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -38,7 +39,13 @@ var (
 )
 
 func TestPartialRetrieval(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_RETRIEVAL_RETRIEVE_001
 	ctx := context.Background()
 
 	policy.SetPreCommitChallengeDelay(2)

itests/deals_power_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -9,6 +10,12 @@ import (
 )
 
 func TestFirstDealEnablesMining(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	// test making a deal with a fresh miner, and see if it starts to mine.
 	if testing.Short() {
 		t.Skip("skipping test in short mode")

itests/deals_pricing_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -12,6 +13,12 @@ import (
 )
 
 func TestQuotePriceForUnsealedRetrieval(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	var (
 		ctx       = context.Background()
 		blocktime = 50 * time.Millisecond
@@ -43,10 +50,12 @@ func TestQuotePriceForUnsealedRetrieval(t *testing.T) {
 	_, res2, _ := dh.MakeOnlineDeal(ctx, kit.MakeFullDealParams{Rseed: 6})
 	require.Equal(t, res1.Root, res2.Root)
 
+	//stm: @CLIENT_STORAGE_DEALS_GET_001
 	// Retrieval
 	dealInfo, err := client.ClientGetDealInfo(ctx, *deal1)
 	require.NoError(t, err)
 
+	//stm: @CLIENT_RETRIEVAL_FIND_001
 	// fetch quote -> zero for unsealed price since unsealed file already exists.
 	offers, err := client.ClientFindData(ctx, res1.Root, &dealInfo.PieceCID)
 	require.NoError(t, err)
@@ -56,11 +65,13 @@ func TestQuotePriceForUnsealedRetrieval(t *testing.T) {
 	require.Equal(t, dealInfo.Size*uint64(ppb), offers[0].MinPrice.Uint64())
 
 	// remove ONLY one unsealed file
+	//stm: @STORAGE_LIST_001, @MINER_SECTOR_LIST_001
 	ss, err := miner.StorageList(context.Background())
 	require.NoError(t, err)
 	_, err = miner.SectorsList(ctx)
 	require.NoError(t, err)
 
+	//stm: @STORAGE_DROP_SECTOR_001, @STORAGE_LIST_001
 iLoop:
 	for storeID, sd := range ss {
 		for _, sector := range sd {
@@ -70,6 +81,7 @@ iLoop:
 		}
 	}
 
+	//stm: @CLIENT_RETRIEVAL_FIND_001
 	// get retrieval quote -> zero for unsealed price as unsealed file exists.
 	offers, err = client.ClientFindData(ctx, res1.Root, &dealInfo.PieceCID)
 	require.NoError(t, err)
@@ -89,6 +101,7 @@ iLoop:
 		}
 	}
 
+	//stm: @CLIENT_RETRIEVAL_FIND_001
 	// fetch quote -> non-zero for unseal price as we no more unsealed files.
 	offers, err = client.ClientFindData(ctx, res1.Root, &dealInfo.PieceCID)
 	require.NoError(t, err)
@@ -100,6 +113,10 @@ iLoop:
 }
 
 func TestZeroPricePerByteRetrieval(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}

itests/deals_publish_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -23,6 +24,12 @@ import (
 )
 
 func TestPublishDealsBatching(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	var (
 		ctx            = context.Background()
 		publishPeriod  = 10 * time.Second
@@ -103,6 +110,7 @@ func TestPublishDealsBatching(t *testing.T) {
 	}
 
 	// Expect a single PublishStorageDeals message that includes the first two deals
+	//stm: @CHAIN_STATE_LIST_MESSAGES_001
 	msgCids, err := client.StateListMessages(ctx, &api.MessageMatch{To: market.Address}, types.EmptyTSK, 1)
 	require.NoError(t, err)
 	count := 0

itests/deals_retry_deal_no_funds_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -26,6 +27,13 @@ var (
 )
 
 func TestDealsRetryLackOfFunds(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	ctx := context.Background()
 	oldDelay := policy.GetPreCommitChallengeDelay()
 	policy.SetPreCommitChallengeDelay(5)
@@ -105,6 +113,11 @@ func TestDealsRetryLackOfFunds(t *testing.T) {
 }
 
 func TestDealsRetryLackOfFunds_blockInPublishDeal(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	ctx := context.Background()
 	oldDelay := policy.GetPreCommitChallengeDelay()
 	policy.SetPreCommitChallengeDelay(5)
@@ -181,6 +194,11 @@ func TestDealsRetryLackOfFunds_blockInPublishDeal(t *testing.T) {
 }
 
 func TestDealsRetryLackOfFunds_belowLimit(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	ctx := context.Background()
 	oldDelay := policy.GetPreCommitChallengeDelay()
 	policy.SetPreCommitChallengeDelay(5)

itests/deals_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -9,6 +10,12 @@ import (
 )
 
 func TestDealsWithSealingAndRPC(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}

itests/gateway_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -38,6 +39,12 @@ const (
 // TestGatewayWalletMsig tests that API calls to wallet and msig can be made on a lite
 // node that is connected through a gateway to a full API node
 func TestGatewayWalletMsig(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.QuietMiningLogs()
 
 	blocktime := 5 * time.Millisecond
@@ -116,6 +123,7 @@ func TestGatewayWalletMsig(t *testing.T) {
 	addProposal, err := doSend(proto)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	res, err := lite.StateWaitMsg(ctx, addProposal, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
@@ -127,6 +135,7 @@ func TestGatewayWalletMsig(t *testing.T) {
 	// Get available balance of msig: should be greater than zero and less
 	// than initial amount
 	msig := execReturn.IDAddress
+	//stm: @CHAIN_STATE_MINER_AVAILABLE_BALANCE_001
 	msigBalance, err := lite.MsigGetAvailableBalance(ctx, msig, types.EmptyTSK)
 	require.NoError(t, err)
 	require.Greater(t, msigBalance.Int64(), int64(0))
@@ -139,6 +148,7 @@ func TestGatewayWalletMsig(t *testing.T) {
 	addProposal, err = doSend(proto)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	res, err = lite.StateWaitMsg(ctx, addProposal, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
@@ -156,6 +166,7 @@ func TestGatewayWalletMsig(t *testing.T) {
 	approval1, err := doSend(proto)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	res, err = lite.StateWaitMsg(ctx, approval1, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
@@ -169,6 +180,10 @@ func TestGatewayWalletMsig(t *testing.T) {
 // TestGatewayMsigCLI tests that msig CLI calls can be made
 // on a lite node that is connected through a gateway to a full API node
 func TestGatewayMsigCLI(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	kit.QuietMiningLogs()
 
 	blocktime := 5 * time.Millisecond
@@ -180,6 +195,10 @@ func TestGatewayMsigCLI(t *testing.T) {
 }
 
 func TestGatewayDealFlow(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	kit.QuietMiningLogs()
 
 	blocktime := 5 * time.Millisecond
@@ -202,6 +221,10 @@ func TestGatewayDealFlow(t *testing.T) {
 }
 
 func TestGatewayCLIDealFlow(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	kit.QuietMiningLogs()
 
 	blocktime := 5 * time.Millisecond

itests/get_messages_in_ts_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -16,6 +17,12 @@ import (
 )
 
 func TestChainGetMessagesInTs(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	ctx := context.Background()
 
 	kit.QuietMiningLogs()
@@ -84,6 +91,7 @@ func TestChainGetMessagesInTs(t *testing.T) {
 	}
 
 	for _, sm := range sms {
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		msgLookup, err := client.StateWaitMsg(ctx, sm.Cid(), 3, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 

itests/multisig_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -10,6 +11,12 @@ import (
 
 // TestMultisig does a basic test to exercise the multisig CLI commands
 func TestMultisig(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.QuietMiningLogs()
 
 	blockTime := 5 * time.Millisecond

itests/nonce_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -13,6 +14,12 @@ import (
 )
 
 func TestNonceIncremental(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	ctx := context.Background()
 
 	kit.QuietMiningLogs()
@@ -51,6 +58,7 @@ func TestNonceIncremental(t *testing.T) {
 	}
 
 	for _, sm := range sms {
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		_, err := client.StateWaitMsg(ctx, sm.Cid(), 3, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 	}

itests/paych_api_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -27,6 +28,12 @@ import (
 )
 
 func TestPaymentChannelsAPI(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.QuietMiningLogs()
 
 	ctx := context.Background()
@@ -107,6 +114,7 @@ func TestPaymentChannelsAPI(t *testing.T) {
 	require.NoError(t, err)
 	preds := state.NewStatePredicates(paymentCreator)
 	finished := make(chan struct{})
+	//stm: @CHAIN_STATE_GET_ACTOR_001
 	err = ev.StateChanged(func(ctx context.Context, ts *types.TipSet) (done bool, more bool, err error) {
 		act, err := paymentCreator.StateGetActor(ctx, channel, ts.Key())
 		if err != nil {
@@ -182,6 +190,7 @@ func TestPaymentChannelsAPI(t *testing.T) {
 	collectMsg, err := paymentReceiver.PaychCollect(ctx, channel)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	res, err = paymentReceiver.StateWaitMsg(ctx, collectMsg, 3, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode, "unable to collect on payment channel")

itests/paych_cli_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -30,6 +31,12 @@ import (
 // TestPaymentChannelsBasic does a basic test to exercise the payment channel CLI
 // commands
 func TestPaymentChannelsBasic(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	kit.QuietMiningLogs()
 
@@ -87,6 +94,10 @@ type voucherSpec struct {
 
 // TestPaymentChannelStatus tests the payment channel status CLI command
 func TestPaymentChannelStatus(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	kit.QuietMiningLogs()
 
@@ -167,6 +178,12 @@ func TestPaymentChannelStatus(t *testing.T) {
 // TestPaymentChannelVouchers does a basic test to exercise some payment
 // channel voucher commands
 func TestPaymentChannelVouchers(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	kit.QuietMiningLogs()
 
@@ -299,6 +316,12 @@ func TestPaymentChannelVouchers(t *testing.T) {
 // TestPaymentChannelVoucherCreateShortfall verifies that if a voucher amount
 // is greater than what's left in the channel, voucher create fails
 func TestPaymentChannelVoucherCreateShortfall(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	kit.QuietMiningLogs()
 

itests/sdr_upgrade_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -17,6 +18,15 @@ import (
 )
 
 func TestSDRUpgrade(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @CHAIN_STATE_NETWORK_VERSION_001
+
+	//stm: @MINER_SECTOR_LIST_001
 	kit.QuietMiningLogs()
 
 	// oldDelay := policy.GetPreCommitChallengeDelay()

itests/sector_finalize_early_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -18,6 +19,13 @@ import (
 )
 
 func TestDealsWithFinalizeEarly(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @STORAGE_INFO_001
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}
@@ -42,6 +50,7 @@ func TestDealsWithFinalizeEarly(t *testing.T) {
 	miner.AddStorage(ctx, t, 1000000000, true, false)
 	miner.AddStorage(ctx, t, 1000000000, false, true)
 
+	//stm: @STORAGE_LIST_001
 	sl, err := miner.StorageList(ctx)
 	require.NoError(t, err)
 	for si, d := range sl {
@@ -55,6 +64,7 @@ func TestDealsWithFinalizeEarly(t *testing.T) {
 		dh.RunConcurrentDeals(kit.RunConcurrentDealsOpts{N: 1})
 	})
 
+	//stm: @STORAGE_LIST_001
 	sl, err = miner.StorageList(ctx)
 	require.NoError(t, err)
 	for si, d := range sl {

itests/sector_miner_collateral_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -21,6 +22,13 @@ import (
 )
 
 func TestMinerBalanceCollateral(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
+	//stm: @MINER_SECTOR_LIST_001
 	kit.QuietMiningLogs()
 
 	blockTime := 5 * time.Millisecond

itests/sector_pledge_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -22,6 +23,12 @@ import (
 )
 
 func TestPledgeSectors(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.QuietMiningLogs()
 
 	blockTime := 50 * time.Millisecond
@@ -54,6 +61,7 @@ func TestPledgeSectors(t *testing.T) {
 }
 
 func TestPledgeBatching(t *testing.T) {
+	//stm: @SECTOR_PRE_COMMIT_FLUSH_001, @SECTOR_COMMIT_FLUSH_001
 	blockTime := 50 * time.Millisecond
 
 	runTest := func(t *testing.T, nSectors int) {
@@ -110,6 +118,12 @@ func TestPledgeBatching(t *testing.T) {
 }
 
 func TestPledgeMaxBatching(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	blockTime := 50 * time.Millisecond
 
 	runTest := func(t *testing.T) {
@@ -173,6 +187,7 @@ func TestPledgeMaxBatching(t *testing.T) {
 		}
 
 		// Ensure that max aggregate message has propagated to the other node by checking current state
+		//stm: @CHAIN_STATE_MINER_SECTORS_001
 		sectorInfosAfter, err := full.StateMinerSectors(ctx, miner.ActorAddr, nil, types.EmptyTSK)
 		require.NoError(t, err)
 		assert.Equal(t, miner5.MaxAggregatedSectors+kit.DefaultPresealsPerBootstrapMiner, len(sectorInfosAfter))
@@ -182,6 +197,12 @@ func TestPledgeMaxBatching(t *testing.T) {
 }
 
 func TestPledgeBeforeNv13(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	blocktime := 50 * time.Millisecond
 
 	runTest := func(t *testing.T, nSectors int) {

itests/sector_terminate_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -14,6 +15,12 @@ import (
 )
 
 func TestTerminate(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -33,6 +40,7 @@ func TestTerminate(t *testing.T) {
 	ssz, err := miner.ActorSectorSize(ctx, maddr)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 	require.Equal(t, p.MinerPower, p.TotalPower)
@@ -45,6 +53,7 @@ func TestTerminate(t *testing.T) {
 	t.Log("wait for power")
 
 	{
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		// Wait until proven.
 		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 		require.NoError(t, err)
@@ -58,6 +67,7 @@ func TestTerminate(t *testing.T) {
 
 	nSectors++
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 	require.Equal(t, p.MinerPower, p.TotalPower)
@@ -67,6 +77,7 @@ func TestTerminate(t *testing.T) {
 
 	toTerminate := abi.SectorNumber(3)
 
+	//stm: @SECTOR_TERMINATE_001
 	err = miner.SectorTerminate(ctx, toTerminate)
 	require.NoError(t, err)
 
@@ -79,6 +90,7 @@ loop:
 		t.Log("state: ", si.State, msgTriggerred)
 
 		switch sealing.SectorState(si.State) {
+		//stm: @SECTOR_TERMINATE_PENDING_001
 		case sealing.Terminating:
 			if !msgTriggerred {
 				{
@@ -111,6 +123,7 @@ loop:
 	// need to wait for message to be mined and applied.
 	time.Sleep(5 * time.Second)
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	// check power decreased
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
@@ -119,6 +132,7 @@ loop:
 
 	// check in terminated set
 	{
+		//stm: @CHAIN_STATE_MINER_GET_PARTITIONS_001
 		parts, err := client.StateMinerPartitions(ctx, maddr, 1, types.EmptyTSK)
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)
@@ -133,6 +147,7 @@ loop:
 		require.Equal(t, uint64(0), bflen(parts[0].LiveSectors))
 	}
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -141,6 +156,7 @@ loop:
 	ts := client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
 	t.Logf("Now head.Height = %d", ts.Height())
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 

itests/tape_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -14,6 +15,12 @@ import (
 )
 
 func TestTapeFix(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.QuietMiningLogs()
 
 	var blocktime = 2 * time.Millisecond

itests/verifreg_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -23,6 +24,12 @@ import (
 )
 
 func TestVerifiedClientTopUp(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	blockTime := 100 * time.Millisecond
 
 	test := func(nv network.Version, shouldWork bool) func(*testing.T) {
@@ -51,6 +58,7 @@ func TestVerifiedClientTopUp(t *testing.T) {
 			defer cancel()
 
 			// get VRH
+			//stm: @CHAIN_STATE_VERIFIED_REGISTRY_ROOT_KEY_001
 			vrh, err := api.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
 			fmt.Println(vrh.String())
 			require.NoError(t, err)
@@ -81,6 +89,7 @@ func TestVerifiedClientTopUp(t *testing.T) {
 			sm, err := api.MpoolPushMessage(ctx, msg, nil)
 			require.NoError(t, err, "AddVerifier failed")
 
+			//stm: @CHAIN_STATE_WAIT_MSG_001
 			res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
 			require.NoError(t, err)
 			require.EqualValues(t, 0, res.Receipt.ExitCode)
@@ -102,11 +111,13 @@ func TestVerifiedClientTopUp(t *testing.T) {
 			sm, err = api.MpoolPushMessage(ctx, msg, nil)
 			require.NoError(t, err)
 
+			//stm: @CHAIN_STATE_WAIT_MSG_001
 			res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
 			require.NoError(t, err)
 			require.EqualValues(t, 0, res.Receipt.ExitCode)
 
 			// check datacap balance
+			//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
 			dcap, err := api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
 			require.NoError(t, err)
 

itests/wdpost_dispute_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -20,6 +21,12 @@ import (
 )
 
 func TestWindowPostDispute(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -61,6 +68,7 @@ func TestWindowPostDispute(t *testing.T) {
 	evilMinerAddr, err := evilMiner.ActorAddress(ctx)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err := client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -72,6 +80,7 @@ func TestWindowPostDispute(t *testing.T) {
 	ts := client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
 	t.Logf("Now head.Height = %d", ts.Height())
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err := client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -81,9 +90,11 @@ func TestWindowPostDispute(t *testing.T) {
 	// make sure it has gained power.
 	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)))
 
+	//stm: @MINER_SECTOR_LIST_001
 	evilSectors, err := evilMiner.SectorsList(ctx)
 	require.NoError(t, err)
 	evilSectorNo := evilSectors[0] // only one.
+	//stm: @CHAIN_STATE_SECTOR_PARTITION_001
 	evilSectorLoc, err := client.StateSectorPartition(ctx, evilMinerAddr, evilSectorNo, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -96,6 +107,7 @@ func TestWindowPostDispute(t *testing.T) {
 
 	// Wait until we need to prove our sector.
 	for {
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
 		require.NoError(t, err)
 		if di.Index == evilSectorLoc.Deadline && di.CurrentEpoch-di.PeriodStart > 1 {
@@ -109,6 +121,7 @@ func TestWindowPostDispute(t *testing.T) {
 
 	// Wait until after the proving period.
 	for {
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
 		require.NoError(t, err)
 		if di.Index != evilSectorLoc.Deadline {
@@ -119,6 +132,7 @@ func TestWindowPostDispute(t *testing.T) {
 
 	t.Log("accepted evil proof")
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	// Make sure the evil node didn't lose any power.
 	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
 	require.NoError(t, err)
@@ -145,11 +159,13 @@ func TestWindowPostDispute(t *testing.T) {
 		require.NoError(t, err)
 
 		t.Log("waiting dispute")
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Zero(t, rec.Receipt.ExitCode, "dispute not accepted: %s", rec.Receipt.ExitCode.Error())
 	}
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	// Objection SUSTAINED!
 	// Make sure the evil node lost power.
 	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
@@ -162,6 +178,7 @@ func TestWindowPostDispute(t *testing.T) {
 	// First, recover the sector.
 
 	{
+		//stm: @CHAIN_STATE_MINER_INFO_001
 		minerInfo, err := client.StateMinerInfo(ctx, evilMinerAddr, types.EmptyTSK)
 		require.NoError(t, err)
 
@@ -186,6 +203,7 @@ func TestWindowPostDispute(t *testing.T) {
 		sm, err := client.MpoolPushMessage(ctx, msg, nil)
 		require.NoError(t, err)
 
+		//stm: @CHAIN_STATE_WAIT_MSG_001
 		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Zero(t, rec.Receipt.ExitCode, "recovery not accepted: %s", rec.Receipt.ExitCode.Error())
@@ -193,6 +211,7 @@ func TestWindowPostDispute(t *testing.T) {
 
 	// Then wait for the deadline.
 	for {
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
 		require.NoError(t, err)
 		if di.Index == evilSectorLoc.Deadline {
@@ -210,6 +229,11 @@ func TestWindowPostDispute(t *testing.T) {
 }
 
 func TestWindowPostDisputeFails(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+	//stm: @CHAIN_STATE_MINER_GET_DEADLINES_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -232,6 +256,7 @@ func TestWindowPostDisputeFails(t *testing.T) {
 
 	miner.PledgeSectors(ctx, 10, 0, nil)
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -246,6 +271,7 @@ func TestWindowPostDisputeFails(t *testing.T) {
 	require.NoError(t, err)
 	expectedPower := types.NewInt(uint64(ssz) * (kit.DefaultPresealsPerBootstrapMiner + 10))
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -271,6 +297,7 @@ waitForProof:
 	}
 
 	for {
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 		require.NoError(t, err)
 		// wait until the deadline finishes.
@@ -314,11 +341,13 @@ func submitBadProof(
 		return err
 	}
 
+	//stm: @CHAIN_STATE_MINER_INFO_001
 	minerInfo, err := client.StateMinerInfo(ctx, maddr, head.Key())
 	if err != nil {
 		return err
 	}
 
+	//stm: @CHAIN_STATE_GET_RANDOMNESS_FROM_TICKETS_001
 	commEpoch := di.Open
 	commRand, err := client.StateGetRandomnessFromTickets(
 		ctx, crypto.DomainSeparationTag_PoStChainCommit,
@@ -355,6 +384,7 @@ func submitBadProof(
 		return err
 	}
 
+	//stm: @CHAIN_STATE_WAIT_MSG_001
 	rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return err

itests/wdpost_test.go

@@ -1,3 +1,4 @@
+//stm: #integration
 package itests
 
 import (
@@ -23,6 +24,12 @@ import (
 )
 
 func TestWindowedPost(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -58,6 +65,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 	maddr, err := miner.ActorAddress(ctx)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -71,6 +79,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 	ts := client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
 	t.Logf("Now head.Height = %d", ts.Height())
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -84,6 +93,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 
 	// Drop 2 sectors from deadline 2 partition 0 (full partition / deadline)
 	{
+		//stm: @CHAIN_STATE_MINER_GET_PARTITIONS_001
 		parts, err := client.StateMinerPartitions(ctx, maddr, 2, types.EmptyTSK)
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)
@@ -109,6 +119,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 
 	// Drop 1 sectors from deadline 3 partition 0
 	{
+		//stm: @CHAIN_STATE_MINER_GET_PARTITIONS_001
 		parts, err := client.StateMinerPartitions(ctx, maddr, 3, types.EmptyTSK)
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)
@@ -137,6 +148,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 		require.NoError(t, err)
 	}
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -147,6 +159,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 	ts = client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
 	t.Logf("Now head.Height = %d", ts.Height())
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -160,6 +173,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 	err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, false)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -169,6 +183,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 	ts = client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
 	t.Logf("Now head.Height = %d", ts.Height())
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -183,6 +198,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 
 	{
 		// Wait until proven.
+		//stm: @CHAIN_STATE_MINER_CALCULATE_DEADLINE_001
 		di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 		require.NoError(t, err)
 
@@ -193,6 +209,7 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 		t.Logf("Now head.Height = %d", ts.Height())
 	}
 
+	//stm: @CHAIN_STATE_MINER_POWER_001
 	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
@@ -203,6 +220,12 @@ func testWindowPostUpgrade(t *testing.T, blocktime time.Duration, nSectors int,
 }
 
 func TestWindowPostBaseFeeNoBurn(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -225,10 +248,12 @@ func TestWindowPostBaseFeeNoBurn(t *testing.T) {
 	maddr, err := miner.ActorAddress(ctx)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_INFO_001
 	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
 	miner.PledgeSectors(ctx, nSectors, 0, nil)
+	//stm: @CHAIN_STATE_GET_ACTOR_001
 	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
 	require.NoError(t, err)
 	en := wact.Nonce
@@ -237,6 +262,7 @@ func TestWindowPostBaseFeeNoBurn(t *testing.T) {
 
 waitForProof:
 	for {
+		//stm: @CHAIN_STATE_GET_ACTOR_001
 		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
 		require.NoError(t, err)
 		if wact.Nonce > en {
@@ -246,9 +272,11 @@ waitForProof:
 		build.Clock.Sleep(blocktime)
 	}
 
+	//stm: @CHAIN_STATE_LIST_MESSAGES_001
 	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_REPLAY_001
 	pmr, err := client.StateReplay(ctx, types.EmptyTSK, slm[0])
 	require.NoError(t, err)
 
@@ -256,6 +284,12 @@ waitForProof:
 }
 
 func TestWindowPostBaseFeeBurn(t *testing.T) {
+	//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
+	//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
+	//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
+	//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
+
+	//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
 	kit.Expensive(t)
 
 	kit.QuietMiningLogs()
@@ -271,10 +305,12 @@ func TestWindowPostBaseFeeBurn(t *testing.T) {
 	maddr, err := miner.ActorAddress(ctx)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_MINER_INFO_001
 	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
 	miner.PledgeSectors(ctx, 10, 0, nil)
+	//stm: @CHAIN_STATE_GET_ACTOR_001
 	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
 	require.NoError(t, err)
 	en := wact.Nonce
@@ -283,6 +319,7 @@ func TestWindowPostBaseFeeBurn(t *testing.T) {
 
 waitForProof:
 	for {
+		//stm: @CHAIN_STATE_GET_ACTOR_001
 		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
 		require.NoError(t, err)
 		if wact.Nonce > en {
@@ -292,9 +329,11 @@ waitForProof:
 		build.Clock.Sleep(blocktime)
 	}
 
+	//stm: @CHAIN_STATE_LIST_MESSAGES_001
 	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
 	require.NoError(t, err)
 
+	//stm: @CHAIN_STATE_REPLAY_001
 	pmr, err := client.StateReplay(ctx, types.EmptyTSK, slm[0])
 	require.NoError(t, err)
 

markets/retrievaladapter/provider_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package retrievaladapter
 
 import (
@@ -18,6 +19,7 @@ import (
 )
 
 func TestGetPricingInput(t *testing.T) {
+	//stm: @CHAIN_STATE_MARKET_STORAGE_DEAL_001
 	ctx := context.Background()
 	tsk := &types.TipSet{}
 	key := tsk.Key()

markets/storageadapter/dealstatematcher_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package storageadapter
 
 import (
@@ -27,6 +28,7 @@ import (
 )
 
 func TestDealStateMatcher(t *testing.T) {
+	//stm: @CHAIN_STATE_GET_ACTOR_001
 	ctx := context.Background()
 	bs := bstore.NewMemorySync()
 	store := adt2.WrapStore(ctx, cbornode.NewCborStore(bs))

node/config/load_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package config
 
 import (

node/impl/client/client_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package client
 
 import (
@@ -31,6 +32,7 @@ import (
 var testdata embed.FS
 
 func TestImportLocal(t *testing.T) {
+	//stm: @CLIENT_STORAGE_DEALS_IMPORT_LOCAL_001, @CLIENT_RETRIEVAL_FIND_001
 	ds := dssync.MutexWrap(datastore.NewMapDatastore())
 	dir := t.TempDir()
 	im := imports.NewManager(ds, dir)
@@ -44,6 +46,7 @@ func TestImportLocal(t *testing.T) {
 	b, err := testdata.ReadFile("testdata/payload.txt")
 	require.NoError(t, err)
 
+	//stm: @CLIENT_STORAGE_DEALS_LIST_IMPORTS_001
 	root, err := a.ClientImportLocal(ctx, bytes.NewReader(b))
 	require.NoError(t, err)
 	require.NotEqual(t, cid.Undef, root)
@@ -56,6 +59,7 @@ func TestImportLocal(t *testing.T) {
 	require.Equal(t, root, *it.Root)
 	require.True(t, strings.HasPrefix(it.CARPath, dir))
 
+	//stm: @CLIENT_DATA_HAS_LOCAL_001
 	local, err := a.ClientHasLocal(ctx, root)
 	require.NoError(t, err)
 	require.True(t, local)

node/impl/client/import_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package client
 
 import (

node/impl/full/gas_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package full
 
 import (

node/repo/fsrepo_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package repo
 
 import (

node/repo/memrepo_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package repo
 
 import (

node/repo/repo_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package repo
 
 import (

paychmgr/paych_test.go

@@ -1,3 +1,4 @@
+//stm: #unit
 package paychmgr
 
 import (
@@ -43,6 +44,9 @@ func TestCheckVoucherValid(t *testing.T) {
 	mock.setAccountAddress(fromAcct, from)
 	mock.setAccountAddress(toAcct, to)
 
+	//stm: @TOKEN_PAYCH_VOUCHER_VALID_001, @TOKEN_PAYCH_VOUCHER_VALID_002, @TOKEN_PAYCH_VOUCHER_VALID_003
+	//stm: @TOKEN_PAYCH_VOUCHER_VALID_004, @TOKEN_PAYCH_VOUCHER_VALID_005, @TOKEN_PAYCH_VOUCHER_VALID_006, @TOKEN_PAYCH_VOUCHER_VALID_007
+	//stm: @TOKEN_PAYCH_VOUCHER_VALID_009, @TOKEN_PAYCH_VOUCHER_VALID_010
 	tcases := []struct {
 		name          string
 		expectError   bool
@@ -242,6 +246,7 @@ func TestCreateVoucher(t *testing.T) {
 		Lane:   1,
 		Amount: voucherLane1Amt,
 	}
+	//stm: @TOKEN_PAYCH_VOUCHER_CREATE_001
 	res, err := s.mgr.CreateVoucher(ctx, s.ch, voucher)
 	require.NoError(t, err)
 	require.NotNil(t, res.Voucher)
@@ -286,6 +291,7 @@ func TestCreateVoucher(t *testing.T) {
 		Lane:   2,
 		Amount: voucherLane2Amt,
 	}
+	//stm: @TOKEN_PAYCH_VOUCHER_CREATE_004
 	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
 	require.NoError(t, err)
 
@@ -296,6 +302,7 @@ func TestCreateVoucher(t *testing.T) {
 }
 
 func TestAddVoucherDelta(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_VOUCHERS_001
 	ctx := context.Background()
 
 	// Set up a manager with a single payment channel
@@ -357,6 +364,7 @@ func TestAddVoucherNextLane(t *testing.T) {
 	require.NoError(t, err)
 	require.EqualValues(t, ci.NextLane, 3)
 
+	//stm: @TOKEN_PAYCH_ALLOCATE_LANE_001
 	// Allocate a lane (should be lane 3)
 	lane, err := s.mgr.AllocateLane(ctx, s.ch)
 	require.NoError(t, err)
@@ -393,6 +401,7 @@ func TestAllocateLane(t *testing.T) {
 	// Set up a manager with a single payment channel
 	s := testSetupMgrWithChannel(t)
 
+	//stm: @TOKEN_PAYCH_ALLOCATE_LANE_001
 	// First lane should be 0
 	lane, err := s.mgr.AllocateLane(ctx, s.ch)
 	require.NoError(t, err)
@@ -447,6 +456,7 @@ func TestAllocateLaneWithExistingLaneState(t *testing.T) {
 	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)
 	require.NoError(t, err)
 
+	//stm: @TOKEN_PAYCH_ALLOCATE_LANE_001
 	// Allocate lane should return the next lane (lane 3)
 	lane, err := mgr.AllocateLane(ctx, ch)
 	require.NoError(t, err)
@@ -509,6 +519,7 @@ func TestAddVoucherInboundWalletKey(t *testing.T) {
 }
 
 func TestBestSpendable(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_VOUCHERS_001
 	ctx := context.Background()
 
 	// Set up a manager with a single payment channel
@@ -551,6 +562,7 @@ func TestBestSpendable(t *testing.T) {
 		},
 	})
 
+	//stm: @TOKEN_PAYCH_BEST_SPENDABLE_001
 	// Verify best spendable vouchers on each lane
 	vouchers, err := BestSpendableByLane(ctx, bsapi, s.ch)
 	require.NoError(t, err)
@@ -691,6 +703,7 @@ func TestSubmitVoucher(t *testing.T) {
 	err = p3.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
 	require.NoError(t, err)
 
+	//stm: @TOKEN_PAYCH_LIST_VOUCHERS_001
 	// Verify that vouchers are marked as submitted
 	vis, err := s.mgr.ListVouchers(ctx, s.ch)
 	require.NoError(t, err)

paychmgr/paychget_test.go

@@ -68,6 +68,7 @@ func TestPaychGetCreateChannelMsg(t *testing.T) {
 // TestPaychGetCreateChannelThenAddFunds tests creating a channel and then
 // adding funds to it
 func TestPaychGetCreateChannelThenAddFunds(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -158,6 +159,7 @@ func TestPaychGetCreateChannelThenAddFunds(t *testing.T) {
 // operation is queued up behind a create channel operation, and the create
 // channel fails, then the waiting operation can succeed.
 func TestPaychGetCreateChannelWithErrorThenCreateAgain(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -222,6 +224,7 @@ func TestPaychGetCreateChannelWithErrorThenCreateAgain(t *testing.T) {
 // TestPaychGetRecoverAfterError tests that after a create channel fails, the
 // next attempt to create channel can succeed.
 func TestPaychGetRecoverAfterError(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -274,6 +277,7 @@ func TestPaychGetRecoverAfterError(t *testing.T) {
 // TestPaychGetRecoverAfterAddFundsError tests that after an add funds fails, the
 // next attempt to add funds can succeed.
 func TestPaychGetRecoverAfterAddFundsError(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -356,6 +360,7 @@ func TestPaychGetRecoverAfterAddFundsError(t *testing.T) {
 // right after the create channel message is sent, the channel will be
 // created when the system restarts.
 func TestPaychGetRestartAfterCreateChannelMsg(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -435,6 +440,7 @@ func TestPaychGetRestartAfterCreateChannelMsg(t *testing.T) {
 // right after the add funds message is sent, the add funds will be
 // processed when the system restarts.
 func TestPaychGetRestartAfterAddFundsMsg(t *testing.T) {
+	//stm: @TOKEN_PAYCH_LIST_CHANNELS_001, @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -498,6 +504,7 @@ func TestPaychGetRestartAfterAddFundsMsg(t *testing.T) {
 // TestPaychGetWait tests that GetPaychWaitReady correctly waits for the
 // channel to be created or funds to be added
 func TestPaychGetWait(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -555,6 +562,7 @@ func TestPaychGetWait(t *testing.T) {
 
 // TestPaychGetWaitErr tests that GetPaychWaitReady correctly handles errors
 func TestPaychGetWaitErr(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -602,6 +610,7 @@ func TestPaychGetWaitErr(t *testing.T) {
 // TestPaychGetWaitCtx tests that GetPaychWaitReady returns early if the context
 // is cancelled
 func TestPaychGetWaitCtx(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx, cancel := context.WithCancel(context.Background())
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -631,6 +640,7 @@ func TestPaychGetWaitCtx(t *testing.T) {
 // progress and two add funds are queued up behind it, the two add funds
 // will be merged
 func TestPaychGetMergeAddFunds(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -729,6 +739,7 @@ func TestPaychGetMergeAddFunds(t *testing.T) {
 // TestPaychGetMergeAddFundsCtxCancelOne tests that when a queued add funds
 // request is cancelled, its amount is removed from the total merged add funds
 func TestPaychGetMergeAddFundsCtxCancelOne(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -826,6 +837,7 @@ func TestPaychGetMergeAddFundsCtxCancelOne(t *testing.T) {
 // TestPaychGetMergeAddFundsCtxCancelAll tests that when all queued add funds
 // requests are cancelled, no add funds message is sent
 func TestPaychGetMergeAddFundsCtxCancelAll(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 
@@ -900,6 +912,7 @@ func TestPaychGetMergeAddFundsCtxCancelAll(t *testing.T) {
 // TestPaychAvailableFunds tests that PaychAvailableFunds returns the correct
 // channel state
 func TestPaychAvailableFunds(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001, @TOKEN_PAYCH_AVAILABLE_FUNDS_001, @TOKEN_PAYCH_AVAILABLE_FUNDS_002, @TOKEN_PAYCH_AVAILABLE_FUNDS_003
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 

paychmgr/paychvoucherfunds_test.go

@@ -23,6 +23,7 @@ import (
 // insufficient funds, then adding funds to the channel, then adding the
 // voucher again
 func TestPaychAddVoucherAfterAddFunds(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 

paychmgr/settle_test.go

@@ -14,6 +14,7 @@ import (
 )
 
 func TestPaychSettle(t *testing.T) {
+	//stm: @TOKEN_PAYCH_WAIT_READY_001, @TOKEN_PAYCH_SETTLE_001, @TOKEN_PAYCH_LIST_CHANNELS_001
 	ctx := context.Background()
 	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))