Refactor separating AppQC from CommitQC

sei-db/ledger_db/block/blocksim/block_generator.go

@@ -170,19 +170,11 @@ func (g *BlockGenerator) buildFullCommitQC() (*types.FullCommitQC, []*types.Bloc
 
 	viewSpec := types.ViewSpec{CommitQC: prev, Epoch: types.NewEpoch(0, types.OpenRoadRange(), genesisTime, committee, 0)}
 	leader := committee.Leader(viewSpec.View())
-	appQC := func() utils.Option[*types.AppQC] {
-		if n := viewSpec.NextGlobalBlock(); n > 0 {
-			p := types.NewAppProposal(n-1, viewSpec.View().Index, types.AppHash(g.rand.Bytes(hashSizeBytes)), viewSpec.Epoch.EpochIndex())
-			return utils.Some(g.fakeAppQC(p))
-		}
-		return utils.None[*types.AppQC]()
-	}()
 	proposal := utils.OrPanic1(types.NewProposalForTesting(
 		committee,
 		viewSpec,
 		time.Now(),
 		laneQCs,
-		appQC,
 		g.fakeSig(leader),
 	))
 	commitVote := types.NewCommitVote(proposal.Proposal().Msg())

sei-db/ledger_db/block/blocksim/blocksim.go

@@ -178,29 +178,11 @@ func NewBlockSim(
 // countExistingState scans the ledger to count the persisted blocks and QCs,
 // exercising the replay path at startup.
 func countExistingState(db types.BlockDB) (blocks int, qcs int, err error) {
-	it, err := db.Iterator(0)
+	suffix, err := db.ReadSuffix()
 	if err != nil {
-		return 0, 0, fmt.Errorf("failed to open ledger iterator: %w", err)
+		return 0, 0, fmt.Errorf("failed to read suffix ledger data: %w", err)
 	}
-	defer func() { _ = it.Close() }()
-	for {
-		pos, ok, err := it.Next()
-		if err != nil {
-			return 0, 0, fmt.Errorf("failed to advance ledger iterator: %w", err)
-		}
-		if !ok {
-			break
-		}
-		if pos.QC.QC().GlobalRange().First == pos.Number {
-			// The scan entered a new QC's range.
-			qcs++
-		}
-		// Presence comes off the position, so counting never reads a block value.
-		if pos.HasBlock {
-			blocks++
-		}
-	}
-	return blocks, qcs, nil
+	return len(suffix.Blocks), len(suffix.CommitQCs), nil
 }
 
 // recoverResumeState reads the persisted tail so the benchmark resumes appending
@@ -218,8 +200,11 @@ func recoverResumeState(
 	prev := tmutils.None[*types.CommitQC]()
 	highest := tmutils.None[uint64]()
 
-	status := db.Status()
-	if status.NextBlock > 0 {
+	status, ok := db.Status().Get()
+	if !ok {
+		return prev, highest, nil
+	}
+	if status.NextBlock > status.First {
 		highest = tmutils.Some(uint64(status.NextBlock - 1))
 	}
 	if status.NextQC > 0 {

sei-db/ledger_db/block/littblock/codec.go

@@ -16,9 +16,13 @@ import (
 //   - kindBlock     'b' + 8-byte big-endian GlobalBlockNumber (block primary key)
 //   - kindBlockHash 'h' + 32-byte header hash               (block hash alias)
 //   - kindQC        'q' + 8-byte big-endian GlobalBlockNumber (QC primary + covered aliases)
+//   - kindAppQC     'a' + 8-byte big-endian GlobalBlockNumber (AppQC primary + covered aliases)
+//   - kindAppProp   'p' + 8-byte big-endian GlobalBlockNumber (AppProposal primary + covered aliases)
 const (
+	kindAppQC     byte = 'a'
 	kindBlock     byte = 'b'
 	kindBlockHash byte = 'h'
+	kindAppProp   byte = 'p'
 	kindQC        byte = 'q'
 )
 
@@ -32,8 +36,8 @@ func encodeKey(n types.GlobalBlockNumber) []byte {
 }
 
 // decodeKey decodes an 8-byte value produced by encodeKey.
-func decodeKey(b []byte) types.GlobalBlockNumber {
-	return types.GlobalBlockNumber(binary.BigEndian.Uint64(b))
+func decodeKey(b [8]byte) types.GlobalBlockNumber {
+	return types.GlobalBlockNumber(binary.BigEndian.Uint64(b[:]))
 }
 
 // blockKey returns the primary key under which a block at number n is stored.
@@ -53,15 +57,28 @@ func qcKey(n types.GlobalBlockNumber) []byte {
 	return append([]byte{kindQC}, encodeKey(n)...)
 }
 
+// appQCKey returns the key for AppQC number n — used both for an AppQC's
+// primary key and for each covered-number alias.
+func appQCKey(n types.GlobalBlockNumber) []byte {
+	return append([]byte{kindAppQC}, encodeKey(n)...)
+}
+
+// appProposalKey returns the key for AppProposal number n — used both for an
+// AppProposal's primary key and for each covered-number alias.
+func appProposalKey(n types.GlobalBlockNumber) []byte {
+	return append([]byte{kindAppProp}, encodeKey(n)...)
+}
+
 // keyKind returns the kind prefix byte of a stored key.
 func keyKind(key []byte) byte {
 	return key[0]
 }
 
-// decodeNumberKey decodes the GlobalBlockNumber from a kindBlock or kindQC key
-// (i.e. a key whose prefix is followed by an 8-byte big-endian number).
+// decodeNumberKey decodes the GlobalBlockNumber from a kindBlock, kindQC, or
+// kindAppQC key (i.e. a key whose prefix is followed by an 8-byte big-endian
+// number). Panics if key is not 9 bytes (1B kind + 8B GlobalBlockNumber).
 func decodeNumberKey(key []byte) types.GlobalBlockNumber {
-	return decodeKey(key[1:])
+	return decodeKey([8]byte(key[1:]))
 }
 
 // Serialization version for blocks.
@@ -70,6 +87,12 @@ const blockSerializationVersion byte = 1
 // Serialization version for QCs.
 const qcSerializationVersion byte = 1
 
+// Serialization version for AppQCs.
+const appQCSerializationVersion byte = 1
+
+// Serialization version for AppProposals.
+const appProposalSerializationVersion byte = 1
+
 // blockValuePrefixLen is the fixed header preceding a block's proto bytes: one
 // version byte followed by the 8-byte big-endian GlobalBlockNumber.
 const blockValuePrefixLen = 1 + 8
@@ -124,8 +147,8 @@ func encodeQC(qc *types.FullCommitQC) []byte {
 // so deriving from the encoded fields is what makes a QC's range identical
 // before and after a round trip through the table.
 func coveredRange(qc *types.FullCommitQC) (types.GlobalBlockNumber, types.GlobalBlockNumber) {
-	first := qc.QC().GlobalRange().First
-	return first, first + types.GlobalBlockNumber(len(qc.Headers()))
+	gr := qc.QC().GlobalRange()
+	return gr.First, gr.Next
 }
 
 // decodeQC unmarshals a FullCommitQC from the value produced by encodeQC.
@@ -142,3 +165,54 @@ func decodeQC(value []byte) (*types.FullCommitQC, error) {
 	}
 	return qc, nil
 }
+
+// encodeAppProposal marshals an AppProposal to the bytes stored as its table
+// value, framed as [version:1][proto(AppProposal)].
+func encodeAppProposal(appProposal *types.AppProposal) []byte {
+	proto := types.AppProposalConv.Marshal(appProposal)
+	value := make([]byte, 0, 1+len(proto))
+	value = append(value, appProposalSerializationVersion)
+	value = append(value, proto...)
+	return value
+}
+
+// decodeAppProposal unmarshals an AppProposal from the value produced by
+// encodeAppProposal.
+func decodeAppProposal(value []byte) (*types.AppProposal, error) {
+	if len(value) < 1 {
+		return nil, fmt.Errorf("appProposal value too short: %d bytes", len(value))
+	}
+	if value[0] != appProposalSerializationVersion {
+		return nil, fmt.Errorf("unsupported appProposal serialization version %d", value[0])
+	}
+	appProposal, err := types.AppProposalConv.Unmarshal(value[1:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal appProposal: %w", err)
+	}
+	return appProposal, nil
+}
+
+// encodeAppQC marshals an AppQC to the bytes stored as its table value,
+// framed as [version:1][proto(AppQC)].
+func encodeAppQC(appQC *types.AppQC) []byte {
+	proto := types.AppQCConv.Marshal(appQC)
+	value := make([]byte, 0, 1+len(proto))
+	value = append(value, appQCSerializationVersion)
+	value = append(value, proto...)
+	return value
+}
+
+// decodeAppQC unmarshals an AppQC from the value produced by encodeAppQC.
+func decodeAppQC(value []byte) (*types.AppQC, error) {
+	if len(value) < 1 {
+		return nil, fmt.Errorf("appQC value too short: %d bytes", len(value))
+	}
+	if value[0] != appQCSerializationVersion {
+		return nil, fmt.Errorf("unsupported appQC serialization version %d", value[0])
+	}
+	appQC, err := types.AppQCConv.Unmarshal(value[1:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal appQC: %w", err)
+	}
+	return appQC, nil
+}

sei-db/ledger_db/block/littblock/codec_test.go

@@ -23,7 +23,7 @@ func TestKeyRoundTrip(t *testing.T) {
 	for _, n := range cases {
 		key := encodeKey(n)
 		require.Len(t, key, 8, "key must be 8 bytes")
-		require.Equal(t, n, decodeKey(key))
+		require.Equal(t, n, decodeKey([8]byte(key)))
 	}
 }