feat: implement Shasta anchor checkpoint decoding and add related tests

Author: johntaiko

internal/witness/abi.go

@@ -2,6 +2,7 @@ package witness
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"reflect"
 	"strings"
@@ -145,6 +146,21 @@ func decodeAnchorV3ArgsSignalSlots(input []byte) ([][32]byte, error) {
 }
 
 func decodeShastaAnchorCheckpoint(input []byte) (*ShastaCheckpoint, error) {
+	// L2 Shasta anchor transaction (Anchor.anchorV4) encodes a single checkpoint struct:
+	// (uint48 blockNumber, bytes32 blockHash, bytes32 stateRoot) -> 3 static 32-byte words.
+	// This path avoids relying on the L1 ShastaAnchor ABI which includes dynamic fields.
+	if len(input) == 96 {
+		blockNumber := new(big.Int).SetBytes(input[:32])
+		if blockNumber.BitLen() > 48 {
+			return nil, fmt.Errorf("invalid shasta checkpoint block number: %#x", blockNumber)
+		}
+		return &ShastaCheckpoint{
+			BlockNumber: blockNumber.Uint64(),
+			BlockHash:   common.BytesToHash(input[32:64]),
+			StateRoot:   common.BytesToHash(input[64:96]),
+		}, nil
+	}
+
 	if shastaAnchorV4Method.Name == "" {
 		return nil, errors.New("shasta anchor ABI not initialized")
 	}

internal/witness/batch_guest_input.go

@@ -246,22 +246,21 @@ func (g *BatchGuestInput) yieldShastaGuestInputs(yield func(*Pair) bool) {
 			return d
 		}()
 
-		var source manifest.DerivationSourceManifest
-		decodeErr := rlp.DecodeBytes(decoded, &source)
+		source, decodeErr := decodeShastaDerivationSourceManifest(decoded)
 
 		var validManifest *manifest.DerivationSourceManifest
 
 		if idx == len(g.Taiko.DataSources)-1 {
 			// Normal source
-			if decodeErr == nil && validateNormalProposalManifest(g, &source, g.Taiko.ProverData.LastAnchorBlockNumber) {
+			if decodeErr == nil && validateNormalProposalManifest(g, source, g.Taiko.ProverData.LastAnchorBlockNumber) {
 				if !validateShastaBlockBaseFee(g.Inputs, isFirstShastaProposal) {
 					log.Warn("shasta block base fee is invalid, use default manifest")
 					timestamp := clampTimestampLowerBound(lastParentBlockTimestamp, proposalTimestamp)
 					coinbase := g.Taiko.BatchProposed.Proposer()
 					anchorBlockNumber := g.Taiko.ProverData.LastAnchorBlockNumber
 					validManifest = g.createDefaultManifest(timestamp, coinbase, anchorBlockNumber, lastParentBlockGasLimit)
 				} else {
-					validManifest = &source
+					validManifest = source
 				}
 			} else {
 				// Fallback
@@ -272,8 +271,8 @@ func (g *BatchGuestInput) yieldShastaGuestInputs(yield func(*Pair) bool) {
 			}
 		} else {
 			// Force inclusion source
-			if decodeErr == nil && validateForceIncProposalManifest(&source) {
-				validManifest = &source
+			if decodeErr == nil && validateForceIncProposalManifest(source) {
+				validManifest = source
 				if len(source.Blocks) > 0 {
 					lastParentBlockTimestamp = source.Blocks[0].Timestamp
 					lastParentBlockGasLimit = source.Blocks[0].GasLimit
@@ -344,6 +343,29 @@ func combineBlobData(blobs [][eth.BlobSize]byte) ([]byte, error) {
 	return combined, nil
 }
 
+type legacyDerivationSourceManifest struct {
+	Blocks []*manifest.BlockManifest
+}
+
+func decodeShastaDerivationSourceManifest(data []byte) (*manifest.DerivationSourceManifest, error) {
+	// New format: `DerivationSourceManifest` is encoded as `[proverAuthBytes, blocks]`.
+	var decoded manifest.DerivationSourceManifest
+	if err := rlp.DecodeBytes(data, &decoded); err == nil {
+		return &decoded, nil
+	}
+
+	// Legacy format (used by current fixtures and raiko): `DerivationSourceManifest` is encoded as
+	// `[blocks]`, without `proverAuthBytes`.
+	var legacy legacyDerivationSourceManifest
+	if err := rlp.DecodeBytes(data, &legacy); err != nil {
+		return nil, err
+	}
+	return &manifest.DerivationSourceManifest{
+		ProverAuthBytes: nil,
+		Blocks:          legacy.Blocks,
+	}, nil
+}
+
 func (g *BatchGuestInput) BlockProposed() BlockProposed {
 	return g.Taiko.BatchProposed
 }
@@ -825,13 +847,17 @@ func validAnchorInNormalProposal(
 	lastAnchorBlockNumber uint64,
 	proposalBlockNumber uint64,
 ) bool {
+	// NOTE: align with raiko's Shasta rule: the maximum anchor can be `proposalBlockNumber - 1`.
+	// See raiko `valid_anchor_in_normal_proposal` (ANCHOR_MIN_OFFSET = 1).
+	const shastaAnchorMinOffset uint64 = 1
+
 	minAnchor := uint64(0)
 	if proposalBlockNumber > manifest.AnchorMaxOffset {
 		minAnchor = proposalBlockNumber - manifest.AnchorMaxOffset
 	}
 	maxAnchor := uint64(0)
-	if proposalBlockNumber > manifest.AnchorMinOffset {
-		maxAnchor = proposalBlockNumber - manifest.AnchorMinOffset
+	if proposalBlockNumber > shastaAnchorMinOffset {
+		maxAnchor = proposalBlockNumber - shastaAnchorMinOffset
 	}
 
 	hasAnchorGrow := false

internal/witness/batch_guest_input_shasta_test.go

@@ -0,0 +1,82 @@
+package witness
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/taikoxyz/gaiko/tests/fixtures"
+	"github.com/taikoxyz/taiko-mono/packages/taiko-client/pkg/utils"
+)
+
+func TestShastaManifestMatchesInputBlockParams(t *testing.T) {
+	payload, err := fixtures.ReadShastaFixture("input-52.json")
+	require.NoError(t, err)
+
+	var input BatchGuestInput
+	require.NoError(t, json.Unmarshal(payload, &input))
+	require.Len(t, input.Inputs, 1)
+
+	shastaBlock, ok := input.Taiko.BatchProposed.(*ShastaBlockProposed)
+	require.True(t, ok)
+	eventData := shastaBlock.EventData()
+	require.NotNil(t, eventData)
+	require.Len(t, eventData.Proposal.Sources, 1)
+	require.Len(t, input.Taiko.DataSources, 1)
+
+	combined, err := combineBlobData(input.Taiko.DataSources[0].TxDataFromBlob)
+	require.NoError(t, err)
+
+	offset := int(eventData.Proposal.Sources[0].BlobSlice.Offset)
+	require.GreaterOrEqual(t, len(combined), offset+64)
+
+	sizeBytes := combined[offset+32 : offset+64]
+	size := binary.BigEndian.Uint64(sizeBytes[24:])
+	end := offset + 64 + int(size)
+	require.LessOrEqual(t, end, len(combined))
+
+	decoded, err := utils.Decompress(combined[offset+64 : end])
+	require.NoError(t, err)
+
+	m, err := decodeShastaDerivationSourceManifest(decoded)
+	require.NoError(t, err)
+	require.Len(t, m.Blocks, 1)
+
+	require.True(t, validateInputBlockParam(m.Blocks[0], input.Inputs[0].Block))
+}
+
+func TestShastaGuestInputsDoesNotFallbackToDefaultManifest(t *testing.T) {
+	payload, err := fixtures.ReadShastaFixture("input-52.json")
+	require.NoError(t, err)
+
+	var input BatchGuestInput
+	require.NoError(t, json.Unmarshal(payload, &input))
+	require.Len(t, input.Inputs, 1)
+
+	count := 0
+	for range input.GuestInputs() {
+		count++
+	}
+	require.Equal(t, len(input.Inputs), count)
+}
+
+func TestShastaAnchorLinkageDecodesCheckpoint(t *testing.T) {
+	payload, err := fixtures.ReadShastaFixture("input-52.json")
+	require.NoError(t, err)
+
+	var input BatchGuestInput
+	require.NoError(t, json.Unmarshal(payload, &input))
+	require.Len(t, input.Inputs, 1)
+
+	shastaBlock, ok := input.Taiko.BatchProposed.(*ShastaBlockProposed)
+	require.True(t, ok)
+	eventData := shastaBlock.EventData()
+	require.NotNil(t, eventData)
+
+	require.NoError(t, verifyShastaAnchorLinkage(
+		input.Inputs,
+		input.Taiko.L1AncestorHeaders,
+		eventData.Proposal.OriginBlockHash,
+	))
+}