ProposerVM Epochs POC

tests/e2e/c/proposervm_epoch.go

@@ -0,0 +1,100 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package c
+
+import (
+	"math/big"
+	"time"
+
+	"github.com/ava-labs/libevm/core/types"
+	"github.com/onsi/ginkgo/v2"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+
+	"github.com/ava-labs/avalanchego/tests/fixture/e2e"
+	"github.com/ava-labs/avalanchego/utils/units"
+	"github.com/ava-labs/avalanchego/vms/proposervm"
+)
+
+var _ = e2e.DescribeCChain("[ProposerVM Epoch]", func() {
+	tc := e2e.NewTestContext()
+	require := require.New(tc)
+
+	const txAmount = 10 * units.Avax // Arbitrary amount to send and transfer
+
+	ginkgo.It("should advance the proposervm epoch according to the upgrade config epoch duration", func() {
+		// TODO: Skip this test if Granite is not activated
+
+		env := e2e.GetEnv(tc)
+		var (
+			senderKey           = env.PreFundedKey
+			senderEthAddress    = senderKey.EthAddress()
+			recipientKey        = e2e.NewPrivateKey(tc)
+			recipientEthAddress = recipientKey.EthAddress()
+		)
+
+		tc.By("initializing a new eth client")
+		// Select a random node URI to use for both the eth client and
+		// the wallet to avoid having to verify that all nodes are at
+		// the same height before initializing the wallet.
+		nodeURI := env.GetRandomNodeURI()
+		ethClient := e2e.NewEthClient(tc, nodeURI)
+
+		proposerClient := proposervm.NewClient(nodeURI.URI, "C")
+
+		tc.By("issuing C-Chain transactions to advance the epoch", func() {
+			// Issue enough C-Chain transactions to observe the epoch advancing
+			ticker := time.NewTicker(1 * time.Second)
+			defer ticker.Stop()
+
+			// Issue enough txs to activate the proposervm form and ensure we advance the epoch (duration is 4s)
+			const numTxs = 7
+			txCount := 0
+
+			initialEpochNumber, _, _, err := proposerClient.GetEpoch(tc.DefaultContext())
+			require.NoError(err)
+
+			for range ticker.C {
+				acceptedNonce, err := ethClient.AcceptedNonceAt(tc.DefaultContext(), senderEthAddress)
+				require.NoError(err)
+				gasPrice := e2e.SuggestGasPrice(tc, ethClient)
+				tx := types.NewTransaction(
+					acceptedNonce,
+					recipientEthAddress,
+					big.NewInt(int64(txAmount)),
+					e2e.DefaultGasLimit,
+					gasPrice,
+					nil,
+				)
+
+				// Sign transaction
+				cChainID, err := ethClient.ChainID(tc.DefaultContext())
+				require.NoError(err)
+				signer := types.NewEIP155Signer(cChainID)
+				signedTx, err := types.SignTx(tx, signer, senderKey.ToECDSA())
+				require.NoError(err)
+
+				receipt := e2e.SendEthTransaction(tc, ethClient, signedTx)
+				require.Equal(types.ReceiptStatusSuccessful, receipt.Status)
+
+				epochNumber, epochStartTime, pChainHeight, err := proposerClient.GetEpoch(tc.DefaultContext())
+				tc.Log().Debug(
+					"epoch",
+					zap.Uint64("Epoch Number:", epochNumber),
+					zap.Uint64("Epoch Start Time:", epochStartTime),
+					zap.Uint64("P-Chain Height:", pChainHeight),
+				)
+
+				txCount++
+				if txCount >= numTxs {
+					require.Greater(epochNumber, initialEpochNumber,
+						"expected epoch number to advance after issuing %d transactions, but it did not",
+						numTxs,
+					)
+					break
+				}
+			}
+		})
+	})
+})

tests/e2e/e2e_test.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"testing"
+	"time"
 
 	"github.com/onsi/ginkgo/v2"
 	"github.com/stretchr/testify/require"
@@ -50,6 +51,7 @@ var _ = ginkgo.SynchronizedBeforeSuite(func() []byte {
 	upgrades := upgrade.Default
 	if flagVars.ActivateGranite() {
 		upgrades.GraniteTime = upgrade.InitiallyActiveTime
+		upgrades.GraniteEpochDuration = 4 * time.Second
 	} else {
 		upgrades.GraniteTime = upgrade.UnscheduledActivationTime
 	}

upgrade/upgrade.go

@@ -77,28 +77,30 @@ var (
 		EtnaTime:                     InitiallyActiveTime,
 		FortunaTime:                  InitiallyActiveTime,
 		GraniteTime:                  UnscheduledActivationTime,
+		GraniteEpochDuration:         30 * time.Second,
 	}
 
 	ErrInvalidUpgradeTimes = errors.New("invalid upgrade configuration")
 )
 
 type Config struct {
-	ApricotPhase1Time            time.Time `json:"apricotPhase1Time"`
-	ApricotPhase2Time            time.Time `json:"apricotPhase2Time"`
-	ApricotPhase3Time            time.Time `json:"apricotPhase3Time"`
-	ApricotPhase4Time            time.Time `json:"apricotPhase4Time"`
-	ApricotPhase4MinPChainHeight uint64    `json:"apricotPhase4MinPChainHeight"`
-	ApricotPhase5Time            time.Time `json:"apricotPhase5Time"`
-	ApricotPhasePre6Time         time.Time `json:"apricotPhasePre6Time"`
-	ApricotPhase6Time            time.Time `json:"apricotPhase6Time"`
-	ApricotPhasePost6Time        time.Time `json:"apricotPhasePost6Time"`
-	BanffTime                    time.Time `json:"banffTime"`
-	CortinaTime                  time.Time `json:"cortinaTime"`
-	CortinaXChainStopVertexID    ids.ID    `json:"cortinaXChainStopVertexID"`
-	DurangoTime                  time.Time `json:"durangoTime"`
-	EtnaTime                     time.Time `json:"etnaTime"`
-	FortunaTime                  time.Time `json:"fortunaTime"`
-	GraniteTime                  time.Time `json:"graniteTime"`
+	ApricotPhase1Time            time.Time     `json:"apricotPhase1Time"`
+	ApricotPhase2Time            time.Time     `json:"apricotPhase2Time"`
+	ApricotPhase3Time            time.Time     `json:"apricotPhase3Time"`
+	ApricotPhase4Time            time.Time     `json:"apricotPhase4Time"`
+	ApricotPhase4MinPChainHeight uint64        `json:"apricotPhase4MinPChainHeight"`
+	ApricotPhase5Time            time.Time     `json:"apricotPhase5Time"`
+	ApricotPhasePre6Time         time.Time     `json:"apricotPhasePre6Time"`
+	ApricotPhase6Time            time.Time     `json:"apricotPhase6Time"`
+	ApricotPhasePost6Time        time.Time     `json:"apricotPhasePost6Time"`
+	BanffTime                    time.Time     `json:"banffTime"`
+	CortinaTime                  time.Time     `json:"cortinaTime"`
+	CortinaXChainStopVertexID    ids.ID        `json:"cortinaXChainStopVertexID"`
+	DurangoTime                  time.Time     `json:"durangoTime"`
+	EtnaTime                     time.Time     `json:"etnaTime"`
+	FortunaTime                  time.Time     `json:"fortunaTime"`
+	GraniteTime                  time.Time     `json:"graniteTime"`
+	GraniteEpochDuration         time.Duration `json:"graniteEpochDuration"`
 }
 
 func (c *Config) Validate() error {

vms/proposervm/batched_vm_test.go

@@ -596,6 +596,9 @@ func TestBatchedParseBlockParallel(t *testing.T) {
 	parentID := ids.ID{1}
 	timestamp := time.Unix(123, 0)
 	pChainHeight := uint64(2)
+	pChainEpochHeight := uint64(2)
+	epochNumber := uint64(0)
+	epochStartTime := time.Unix(123, 0)
 	chainID := ids.GenerateTestID()
 
 	vm := VM{
@@ -616,10 +619,10 @@ func TestBatchedParseBlockParallel(t *testing.T) {
 
 	blockThatCantBeParsed := snowmantest.BuildChild(snowmantest.Genesis)
 
-	blocksWithUnparsable := makeParseableBlocks(t, parentID, timestamp, pChainHeight, cert, chainID, key)
+	blocksWithUnparsable := makeParseableBlocks(t, parentID, timestamp, pChainHeight, pChainEpochHeight, epochNumber, epochStartTime, cert, chainID, key)
 	blocksWithUnparsable[50] = blockThatCantBeParsed.Bytes()
 
-	parsableBlocks := makeParseableBlocks(t, parentID, timestamp, pChainHeight, cert, chainID, key)
+	parsableBlocks := makeParseableBlocks(t, parentID, timestamp, pChainHeight, pChainEpochHeight, epochNumber, epochStartTime, cert, chainID, key)
 
 	for _, testCase := range []struct {
 		name         string
@@ -663,14 +666,17 @@ func TestBatchedParseBlockParallel(t *testing.T) {
 	}
 }
 
-func makeParseableBlocks(t *testing.T, parentID ids.ID, timestamp time.Time, pChainHeight uint64, cert *staking.Certificate, chainID ids.ID, key crypto.Signer) [][]byte {
+func makeParseableBlocks(t *testing.T, parentID ids.ID, timestamp time.Time, pChainHeight uint64, pChainEpochHeight uint64, epochNumber uint64, epochStartTime time.Time, cert *staking.Certificate, chainID ids.ID, key crypto.Signer) [][]byte {
 	makeSignedBlock := func(i int) []byte {
 		buff := binary.AppendVarint(nil, int64(i))
 
 		signedBlock, err := blockbuilder.Build(
 			parentID,
 			timestamp,
 			pChainHeight,
+			pChainEpochHeight,
+			epochNumber,
+			epochStartTime,
 			cert,
 			buff,
 			chainID,

vms/proposervm/block.go

@@ -59,6 +59,9 @@ type Block interface {
 	buildChild(context.Context) (Block, error)
 
 	pChainHeight(context.Context) (uint64, error)
+	pChainEpochHeight(context.Context) (uint64, error)
+	epochNumber(context.Context) (uint64, error)
+	epochStartTime(context.Context) (time.Time, error)
 }
 
 type PostForkBlock interface {
@@ -79,6 +82,59 @@ func (p *postForkCommonComponents) Height() uint64 {
 	return p.innerBlk.Height()
 }
 
+// Calculates a block's P-Chain epoch height based on its ancestor's epoch membership
+func (p *postForkCommonComponents) getPChainEpoch(ctx context.Context, parentID ids.ID) (uint64, uint64, time.Time, error) {
+	parent, err := p.vm.getBlock(ctx, parentID)
+	if err != nil {
+		return 0, 0, time.Time{}, err
+	}
+	parentTimestamp := parent.Timestamp()
+	epoch, err := parent.epochNumber(ctx)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("failed to get epoch number: %w", err)
+	}
+	epochStartTime, err := parent.epochStartTime(ctx)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("failed to get epoch start time: %w", err)
+	}
+	if epochStartTime.IsZero() {
+		// If the parent was not assigned an epoch, then the child is the first block of
+		// the initial epoch.
+		height, err := parent.pChainHeight(ctx)
+		if err != nil {
+			return 0, 0, time.Time{}, fmt.Errorf("failed to get P-Chain height: %w", err)
+		}
+		return height, 0, parentTimestamp, nil
+	}
+
+	if parentTimestamp.After(epochStartTime.Add(p.vm.Upgrades.GraniteEpochDuration)) {
+		// If the parent crossed the epoch boundary, then it sealed the previous epoch. The child
+		// is the first block of the new epoch, so should use the parent's P-Chain height, increment
+		// the epoch number, and set the epoch start time to the parent's timestamp.
+		height, err := parent.pChainHeight(ctx)
+		if err != nil {
+			return 0, 0, time.Time{}, fmt.Errorf("failed to get P-Chain height: %w", err)
+		}
+		p.vm.ctx.Log.Info("parent sealed epoch. advancing epoch",
+			zap.Uint64("height", height),
+			zap.Uint64("epoch", epoch+1),
+		)
+		return height, epoch + 1, parentTimestamp, nil
+	}
+	// Otherwise, the parent did not seal the previous epoch, so the child should use the parent's
+	// epoch information. This is true even if the child crosses the epoch boundary, since sealing
+	// blocks are considered to be part of the epoch they seal.
+	height, err := parent.pChainEpochHeight(ctx)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("failed to get P-Chain height: %w", err)
+	}
+	p.vm.ctx.Log.Debug("parent did not seal epoch. using parent's epoch",
+		zap.Uint64("height", height),
+		zap.Uint64("epoch", epoch),
+	)
+	return height, epoch, epochStartTime, nil
+}
+
 // Verify returns nil if:
 // 1) [p]'s inner block is not an oracle block
 // 2) [child]'s P-Chain height >= [parentPChainHeight]
@@ -89,6 +145,7 @@ func (p *postForkCommonComponents) Height() uint64 {
 // 7) [child]'s timestamp is within its proposer's window
 // 8) [child] has a valid signature from its proposer
 // 9) [child]'s inner block is valid
+// 10) [child] has the expected P-Chain epoch height
 func (p *postForkCommonComponents) Verify(
 	ctx context.Context,
 	parentTimestamp time.Time,
@@ -163,9 +220,23 @@ func (p *postForkCommonComponents) Verify(
 	}
 
 	var contextPChainHeight uint64
-	if p.vm.Upgrades.IsEtnaActivated(childTimestamp) {
+	switch {
+	case p.vm.Upgrades.IsGraniteActivated(childTimestamp):
+		pChainEpochHeight, _, _, err := p.getPChainEpoch(ctx, child.Parent())
+		if err != nil {
+			p.vm.ctx.Log.Error("unexpected build verification failure",
+				zap.String("reason", "failed to get P-Chain epoch height"),
+				zap.Stringer("parentID", child.Parent()),
+				zap.Error(err),
+			)
+		}
+		if childHeight := child.PChainEpochHeight(); pChainEpochHeight != childHeight {
+			return fmt.Errorf("epoch height mismatch: expectedEpochHeight %d != epochHeight %d", pChainEpochHeight, childHeight)
+		}
+		contextPChainHeight = pChainEpochHeight
+	case p.vm.Upgrades.IsEtnaActivated(childTimestamp):
 		contextPChainHeight = childPChainHeight
-	} else {
+	default:
 		contextPChainHeight = parentPChainHeight
 	}
 
@@ -225,10 +296,31 @@ func (p *postForkCommonComponents) buildChild(
 		return nil, err
 	}
 
-	var contextPChainHeight uint64
-	if p.vm.Upgrades.IsEtnaActivated(newTimestamp) {
+	var (
+		contextPChainHeight, pChainEpochHeight, epochNumber uint64
+		epochStartTime                                      time.Time
+	)
+	switch {
+	case p.vm.Upgrades.IsGraniteActivated(newTimestamp):
+		pChainEpochHeight, epochNumber, epochStartTime, err = p.getPChainEpoch(ctx, parentID)
+		if err != nil {
+			p.vm.ctx.Log.Error("unexpected build block failure",
+				zap.String("reason", "failed to get P-Chain epoch height"),
+				zap.Stringer("parentID", parentID),
+				zap.Error(err),
+			)
+		}
+		p.vm.ctx.Log.Debug(
+			"epoch",
+			zap.Uint64("pChainHeight", pChainHeight),
+			zap.Uint64("pChainEpochHeight", pChainEpochHeight),
+			zap.Uint64("epochNumber", epochNumber),
+			zap.Time("epochStartTime", epochStartTime),
+		)
+		contextPChainHeight = pChainEpochHeight
+	case p.vm.Upgrades.IsEtnaActivated(newTimestamp):
 		contextPChainHeight = pChainHeight
-	} else {
+	default:
 		contextPChainHeight = parentPChainHeight
 	}
 
@@ -251,6 +343,9 @@ func (p *postForkCommonComponents) buildChild(
 			parentID,
 			newTimestamp,
 			pChainHeight,
+			pChainEpochHeight,
+			epochNumber,
+			epochStartTime,
 			p.vm.StakingCertLeaf,
 			innerBlock.Bytes(),
 			p.vm.ctx.ChainID,
@@ -261,6 +356,9 @@ func (p *postForkCommonComponents) buildChild(
 			parentID,
 			newTimestamp,
 			pChainHeight,
+			pChainEpochHeight,
+			epochNumber,
+			epochStartTime,
 			innerBlock.Bytes(),
 		)
 	}