fix(ledger): match Leios/Musashi CDDL exactly at a24a2d69b

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

ledger/common/common.go

@@ -1179,6 +1179,168 @@ func extractByronOutputOffsets(
 	}
 }
 
+// isDijkstraBlock checks whether a decoded block array represents a Dijkstra
+// (prototype-2026w27) block. A Dijkstra block is a 2-element array
+// [header, block_body] where block_body is a 4-element array
+// [invalid_transactions/nil, transactions, leios_certificate/nil,
+// peras_certificate/nil] and each transaction is a 3-element array
+// [transaction_body, transaction_witness_set, auxiliary_data/nil].
+//
+// The 2-element top level distinguishes Dijkstra from Byron (3-element) and
+// Shelley+ (4+ element) blocks. The nested shape check guards against
+// misclassifying an unrelated 2-element value (e.g. a Byron epoch-boundary
+// block, whose second element is a bytestring array, not a 4-element array).
+func isDijkstraBlock(blockArray []cbor.RawMessage) bool {
+	if len(blockArray) != 2 {
+		return false
+	}
+	var bodyParts []cbor.RawMessage
+	if _, err := cbor.Decode([]byte(blockArray[1]), &bodyParts); err != nil {
+		return false
+	}
+	if len(bodyParts) != 4 {
+		return false
+	}
+	// bodyParts[1] is the transactions array.
+	var txs []cbor.RawMessage
+	if _, err := cbor.Decode([]byte(bodyParts[1]), &txs); err != nil {
+		return false
+	}
+	// If there are transactions, verify the first one is a 3-element array.
+	if len(txs) > 0 {
+		var tx []cbor.RawMessage
+		if _, err := cbor.Decode([]byte(txs[0]), &tx); err != nil {
+			return false
+		}
+		if len(tx) != 3 {
+			return false
+		}
+	}
+	return true
+}
+
+// extractDijkstraTransactionOffsets extracts transaction offsets from a
+// Dijkstra (prototype-2026w27) block. The block is [header, block_body] with
+// block_body = [invalid_transactions/nil, transactions, leios_certificate/nil,
+// peras_certificate/nil] and each transaction a complete
+// [transaction_body, transaction_witness_set, auxiliary_data/nil] array (not
+// the pre-Dijkstra parallel body/witness/metadata segments).
+func extractDijkstraTransactionOffsets(
+	cborData []byte,
+	blockArray []cbor.RawMessage,
+) (*BlockTransactionOffsets, error) {
+	topArrayHeader := cborArrayHeaderSize(len(blockArray))
+
+	// blockArray[0] = header, blockArray[1] = block_body
+	blockBodyOffset := topArrayHeader + uint32(len(blockArray[0])) // #nosec G115 -- Cardano block segments are <<4GiB
+
+	var bodyParts []cbor.RawMessage
+	if _, err := cbor.Decode([]byte(blockArray[1]), &bodyParts); err != nil {
+		return nil, fmt.Errorf("failed to decode Dijkstra block body: %w", err)
+	}
+	if len(bodyParts) != 4 {
+		return nil, fmt.Errorf(
+			"dijkstra block body has %d elements, expected 4",
+			len(bodyParts),
+		)
+	}
+
+	// bodyParts[1] = transactions ([* transaction])
+	var txs []cbor.RawMessage
+	if _, err := cbor.Decode([]byte(bodyParts[1]), &txs); err != nil {
+		return nil, fmt.Errorf("failed to decode Dijkstra transactions: %w", err)
+	}
+	if len(txs) == 0 {
+		return &BlockTransactionOffsets{Transactions: []TransactionLocation{}}, nil
+	}
+
+	// Absolute offset of the transactions array: skip the block_body array
+	// header and the invalid_transactions element (bodyParts[0]).
+	var bodyArrayHeader uint32
+	if int(blockBodyOffset) < len(cborData) && cborData[blockBodyOffset] == 0x9f {
+		bodyArrayHeader = 1 // indefinite-length array
+	} else {
+		bodyArrayHeader = cborArrayHeaderSize(len(bodyParts))
+	}
+	txsArrayOffset := blockBodyOffset + bodyArrayHeader + uint32(len(bodyParts[0])) // #nosec G115 -- Cardano block segments are <<4GiB
+
+	var txsArrayHeader uint32
+	if int(txsArrayOffset) < len(cborData) && cborData[txsArrayOffset] == 0x9f {
+		txsArrayHeader = 1 // indefinite-length array
+	} else {
+		txsArrayHeader = cborArrayHeaderSize(len(txs))
+	}
+
+	result := &BlockTransactionOffsets{
+		Transactions: make([]TransactionLocation, len(txs)),
+	}
+
+	// Walk each transaction [transaction_body, transaction_witness_set, aux/nil].
+	txPos := txsArrayOffset + txsArrayHeader
+	for i, rawTx := range txs {
+		var txParts []cbor.RawMessage
+		if _, err := cbor.Decode([]byte(rawTx), &txParts); err != nil {
+			return nil, fmt.Errorf(
+				"failed to decode Dijkstra transaction %d: %w", i, err,
+			)
+		}
+		if len(txParts) != 3 {
+			return nil, fmt.Errorf(
+				"dijkstra transaction %d has %d elements, expected 3",
+				i, len(txParts),
+			)
+		}
+
+		var txArrayHeader uint32
+		if int(txPos) < len(cborData) && cborData[txPos] == 0x9f {
+			txArrayHeader = 1 // indefinite-length array
+		} else {
+			txArrayHeader = cborArrayHeaderSize(len(txParts))
+		}
+
+		bodyStart := txPos + txArrayHeader
+		bodyLen := uint32(len(txParts[0])) // #nosec G115 -- Cardano block segments are <<4GiB
+		witnessStart := bodyStart + bodyLen
+		witnessLen := uint32(len(txParts[1])) // #nosec G115 -- Cardano block segments are <<4GiB
+		auxStart := witnessStart + witnessLen
+		auxLen := uint32(len(txParts[2])) // #nosec G115 -- Cardano block segments are <<4GiB
+
+		result.Transactions[i].Body = ByteRange{
+			Offset: bodyStart,
+			Length: bodyLen,
+		}
+		result.Transactions[i].Witness = ByteRange{
+			Offset: witnessStart,
+			Length: witnessLen,
+		}
+		// auxiliary_data is CBOR null (0xf6) when absent; only record real
+		// metadata so the zero ByteRange keeps its "no metadata" meaning.
+		if !(len(txParts[2]) == 1 && txParts[2][0] == 0xf6) {
+			result.Transactions[i].Metadata = ByteRange{
+				Offset: auxStart,
+				Length: auxLen,
+			}
+		}
+
+		// Populate output and witness-component offsets, matching the Shelley+
+		// path so downstream DOFF indexing works identically.
+		extractOutputOffsets(
+			[]byte(txParts[0]),
+			bodyStart,
+			&result.Transactions[i],
+		)
+		extractWitnessComponentOffsets(
+			[]byte(txParts[1]),
+			witnessStart,
+			&result.Transactions[i],
+		)
+
+		txPos += uint32(len(rawTx)) // #nosec G115 -- Cardano block segments are <<4GiB
+	}
+
+	return result, nil
+}
+
 // ExtractTransactionOffsets extracts byte offsets for all transactions in a block.
 // This enables efficient CBOR extraction from block data without full deserialization.
 //
@@ -1193,6 +1355,15 @@ func ExtractTransactionOffsets(cborData []byte) (*BlockTransactionOffsets, error
 	if _, err := cbor.Decode(cborData, &blockArray); err != nil {
 		return nil, fmt.Errorf("failed to decode block array: %w", err)
 	}
+
+	// Detect Dijkstra (prototype-2026w27) blocks. Unlike pre-Dijkstra eras,
+	// these are a 2-element array [header, block_body] where transactions live
+	// inline inside block_body rather than as parallel top-level segments, so
+	// they must be recognized before the generic short-block early return.
+	if isDijkstraBlock(blockArray) {
+		return extractDijkstraTransactionOffsets(cborData, blockArray)
+	}
+
 	if len(blockArray) < 3 {
 		// Block doesn't have separated components (e.g., Byron EBB)
 		// Return empty slice instead of nil to prevent nil pointer dereference

ledger/common/streaming_decode_test.go

@@ -17,6 +17,7 @@ package common_test
 import (
 	"testing"
 
+	"github.com/blinklabs-io/gouroboros/cbor"
 	"github.com/blinklabs-io/gouroboros/ledger/common"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -143,3 +144,85 @@ func TestExtractWitnessCbor(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, []byte{0x03, 0x04, 0x05}, witness)
 }
+
+// TestExtractTransactionOffsetsDijkstra verifies that ExtractTransactionOffsets
+// recognizes a Dijkstra (prototype-2026w27) 2-element block
+// [header, block_body] and extracts one offset entry per inline transaction,
+// with each extracted body/witness/metadata slice round-tripping to the exact
+// CBOR of the corresponding transaction element.
+func TestExtractTransactionOffsetsDijkstra(t *testing.T) {
+	// tx0: no metadata; tx1: carries auxiliary_data (metadata) and an output.
+	tx0 := []any{
+		map[uint64]any{2: uint64(10)}, // body: {fee: 10}
+		map[uint64]any{},              // empty witness set
+		nil,                           // no auxiliary_data
+	}
+	tx1 := []any{
+		map[uint64]any{ // body: {outputs: [out], fee: 20}
+			1: []any{[]any{[]byte{0xde, 0xad}, uint64(5)}},
+			2: uint64(20),
+		},
+		map[uint64]any{0: []any{}},          // witness set with empty vkey witness list
+		map[uint64]any{uint64(674): "meta"}, // auxiliary_data (metadata)
+	}
+	// A realistic 2-element header placeholder ([body, signature]); its contents
+	// are irrelevant to offset extraction, only its byte length matters.
+	header := []any{[]byte{0x01, 0x02, 0x03}, []byte{0x04}}
+	blockBody := []any{nil, []any{tx0, tx1}, nil, nil}
+	blockCbor, err := cbor.Encode([]any{header, blockBody})
+	require.NoError(t, err)
+
+	offsets, err := common.ExtractTransactionOffsets(blockCbor)
+	require.NoError(t, err)
+	require.Len(t, offsets.Transactions, 2)
+
+	// Independently decode to obtain the authoritative sub-element bytes.
+	var top []cbor.RawMessage
+	_, err = cbor.Decode(blockCbor, &top)
+	require.NoError(t, err)
+	require.Len(t, top, 2)
+	var bodyParts []cbor.RawMessage
+	_, err = cbor.Decode([]byte(top[1]), &bodyParts)
+	require.NoError(t, err)
+	require.Len(t, bodyParts, 4)
+	var txs []cbor.RawMessage
+	_, err = cbor.Decode([]byte(bodyParts[1]), &txs)
+	require.NoError(t, err)
+	require.Len(t, txs, 2)
+
+	for i, rawTx := range txs {
+		var txParts []cbor.RawMessage
+		_, err = cbor.Decode([]byte(rawTx), &txParts)
+		require.NoError(t, err)
+		require.Len(t, txParts, 3)
+		loc := offsets.Transactions[i]
+
+		gotBody := blockCbor[loc.Body.Offset : loc.Body.Offset+loc.Body.Length]
+		assert.Equal(t, []byte(txParts[0]), gotBody, "tx %d body bytes", i)
+
+		gotWit := blockCbor[loc.Witness.Offset : loc.Witness.Offset+loc.Witness.Length]
+		assert.Equal(t, []byte(txParts[1]), gotWit, "tx %d witness bytes", i)
+	}
+
+	// tx0 has no auxiliary_data -> zero Metadata range.
+	assert.Zero(t, offsets.Transactions[0].Metadata.Length)
+	// tx1 carries metadata; the recorded range must round-trip to its aux bytes.
+	var tx1Parts []cbor.RawMessage
+	_, err = cbor.Decode([]byte(txs[1]), &tx1Parts)
+	require.NoError(t, err)
+	m := offsets.Transactions[1].Metadata
+	require.NotZero(t, m.Length)
+	assert.Equal(t, []byte(tx1Parts[2]), blockCbor[m.Offset:m.Offset+m.Length])
+
+	// tx1's single output must also round-trip.
+	require.Len(t, offsets.Transactions[1].Outputs, 1)
+	var body1Parts map[uint64]cbor.RawMessage
+	_, err = cbor.Decode([]byte(tx1Parts[0]), &body1Parts)
+	require.NoError(t, err)
+	var outputs []cbor.RawMessage
+	_, err = cbor.Decode([]byte(body1Parts[1]), &outputs)
+	require.NoError(t, err)
+	require.Len(t, outputs, 1)
+	o := offsets.Transactions[1].Outputs[0]
+	assert.Equal(t, []byte(outputs[0]), blockCbor[o.Offset:o.Offset+o.Length])
+}

ledger/dijkstra.go

@@ -25,7 +25,6 @@ type (
 	DijkstraBlockBody               = dijkstra.DijkstraBlockBody
 	DijkstraBlockHeader             = dijkstra.DijkstraBlockHeader
 	DijkstraLeiosCertificate        = dijkstra.DijkstraLeiosCertificate
-	DijkstraPerasCertificate        = dijkstra.DijkstraPerasCertificate
 	DijkstraTransaction             = dijkstra.DijkstraTransaction
 	DijkstraTransactionBody         = dijkstra.DijkstraTransactionBody
 	DijkstraTransactionOutput       = dijkstra.DijkstraTransactionOutput