Implement RegisterSubnetValidatorTx

tests/e2e/p/permissionless_layer_one.go

@@ -0,0 +1,104 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package p
+
+import (
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/api/info"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/tests/fixture/e2e"
+	"github.com/ava-labs/avalanchego/utils/constants"
+	"github.com/ava-labs/avalanchego/vms/platformvm"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+
+	ginkgo "github.com/onsi/ginkgo/v2"
+)
+
+var _ = e2e.DescribePChain("[Permissionless L1]", func() {
+	tc := e2e.NewTestContext()
+	require := require.New(tc)
+
+	ginkgo.It("e2e flow", func() {
+		env := e2e.GetEnv(tc)
+
+		nodeURI := env.GetRandomNodeURI()
+
+		infoClient := info.NewClient(nodeURI.URI)
+
+		tc.By("get upgrade config")
+		upgrades, err := infoClient.Upgrades(tc.DefaultContext())
+		require.NoError(err)
+
+		now := time.Now()
+		if !upgrades.IsEtnaActivated(now) {
+			ginkgo.Skip("Etna is not activated. Permissionless L1s are enabled post-Etna, skipping test.")
+		}
+
+		keychain := env.NewKeychain(1)
+		baseWallet := e2e.NewWallet(tc, keychain, nodeURI)
+
+		pWallet := baseWallet.P()
+		pClient := platformvm.NewClient(nodeURI.URI)
+
+		owner := &secp256k1fx.OutputOwners{
+			Threshold: 1,
+			Addrs: []ids.ShortID{
+				keychain.Keys[0].Address(),
+			},
+		}
+
+		var subnetID ids.ID
+		tc.By("create a permissioned subnet", func() {
+			subnetTx, err := pWallet.IssueCreateSubnetTx(
+				owner,
+				tc.WithDefaultContext(),
+			)
+
+			subnetID = subnetTx.ID()
+			require.NoError(err)
+			require.NotEqual(subnetID, constants.PrimaryNetworkID)
+
+			res, err := pClient.GetSubnet(tc.DefaultContext(), subnetID)
+			require.NoError(err)
+
+			require.Equal(platformvm.GetSubnetClientResponse{
+				IsPermissioned: true,
+				ControlKeys: []ids.ShortID{
+					keychain.Keys[0].Address(),
+				},
+				Threshold: 1,
+			}, res)
+		})
+
+		chainID := ids.GenerateTestID()
+		address := []byte{'a', 'd', 'd', 'r', 'e', 's', 's'}
+		tc.By("convert subnet to permissionless L1", func() {
+			convertSubnetTx, err := pWallet.IssueConvertSubnetTx(
+				subnetID,
+				chainID,
+				address,
+				tc.WithDefaultContext(),
+			)
+			require.NoError(err)
+
+			require.NoError(platformvm.AwaitTxAccepted(pClient, tc.DefaultContext(), convertSubnetTx.ID(), 100*time.Millisecond))
+
+			res, err := pClient.GetSubnet(tc.DefaultContext(), subnetID)
+			require.NoError(err)
+
+			require.Equal(platformvm.GetSubnetClientResponse{
+				IsPermissioned: false,
+				ControlKeys: []ids.ShortID{
+					keychain.Keys[0].Address(),
+				},
+				Threshold:      1,
+				ManagerChainID: chainID,
+				ManagerAddress: address,
+			}, res)
+		})
+	})
+})

vms/components/fee/validator.go

@@ -0,0 +1,93 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package fee
+
+import (
+	"fmt"
+
+	"github.com/holiman/uint256"
+)
+
+type ValidatorState struct {
+	Current  Gas
+	Target   Gas
+	Capacity Gas
+	Excess   Gas
+	MinFee   GasPrice
+	K        Gas
+}
+
+func (v ValidatorState) CurrentFeeRate() GasPrice {
+	return v.MinFee.MulExp(v.Excess, v.K)
+}
+
+func (v ValidatorState) CalculateContinuousFee(seconds uint64) uint64 {
+	if v.Current == v.Target {
+		return uint64(v.MinFee.MulExp(v.Excess, v.K)) * seconds
+	}
+
+	uint256.NewInt(uint64(v.Excess))
+
+	var totalFee uint64
+	if v.Current < v.Target {
+		secondsTillExcessIsZero := uint64(v.Excess / (v.Target - v.Current))
+
+		if secondsTillExcessIsZero < seconds {
+			totalFee += uint64(v.MinFee) * (seconds - secondsTillExcessIsZero)
+			seconds = secondsTillExcessIsZero
+		}
+	}
+
+	x := v.Excess
+	for i := uint64(1); i <= seconds; i++ {
+		if v.Current < v.Target {
+			x = x.SubPerSecond(v.Target-v.Current, 1)
+		} else {
+			x = x.AddPerSecond(v.Current-v.Target, 1)
+		}
+
+		if x == 0 {
+			totalFee += uint64(v.MinFee)
+			continue
+		}
+
+		totalFee += uint64(v.MinFee.MulExp(x, v.K))
+	}
+
+	return totalFee
+}
+
+// Returns the first number n where CalculateContinuousFee(n) >= balance
+func (v ValidatorState) CalculateTimeTillContinuousFee(balance uint64) (uint64, uint64) {
+	// Lower bound can be derived from [MinFee].
+	n := balance / uint64(v.MinFee)
+	interval := n
+
+	numIters := 0
+	for {
+		fmt.Printf("n=%d", n)
+		feeAtN := v.CalculateContinuousFee(n)
+		feeBeforeN := v.CalculateContinuousFee(n - 1)
+		if feeAtN == balance {
+			return n, uint64(numIters)
+		}
+
+		if feeAtN > balance && feeBeforeN < balance {
+			return n, uint64(numIters)
+		}
+
+		if feeAtN > balance {
+			if interval > 1 {
+				interval /= 2
+			}
+			n -= interval
+		}
+
+		if feeAtN < balance {
+			n += interval
+		}
+
+		numIters++
+	}
+}

vms/components/fee/validator_test.go

@@ -0,0 +1,124 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package fee
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func Test_ValidatorState_CalculateFee(t *testing.T) {
+	var (
+		minute uint64 = 60
+		hour          = 60 * minute
+		day           = 24 * hour
+		week          = 7 * day
+	)
+
+	tests := []struct {
+		name     string
+		initial  ValidatorState
+		seconds  uint64
+		expected uint64
+	}{
+		{
+			name: "excess=0, current<target, minute",
+			initial: ValidatorState{
+				Current:  10,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   0,
+				MinFee:   2_048,
+				K:        60_480_000_000,
+			},
+			seconds:  minute,
+			expected: 122_880,
+		},
+		{
+			name: "excess=0, current>target, minute",
+			initial: ValidatorState{
+				Current:  15_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   0,
+				MinFee:   2_048,
+				K:        60_480_000_000,
+			},
+			seconds:  minute,
+			expected: 122_880,
+		},
+		{
+			name: "excess=K, current=target, minute",
+			initial: ValidatorState{
+				Current:  10_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   60_480_000_000,
+				MinFee:   2_048,
+				K:        60_480_000_000,
+			},
+			seconds:  minute,
+			expected: 334_020,
+		},
+		{
+			name: "excess=0, current>target, day",
+			initial: ValidatorState{
+				Current:  15_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   0,
+				MinFee:   2048,
+				K:        60_480_000_000,
+			},
+			seconds:  day,
+			expected: 177_538_111,
+		},
+		{
+			name: "excess=K, current=target, day",
+			initial: ValidatorState{
+				Current:  10_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   60_480_000_000,
+				MinFee:   2_048,
+				K:        60_480_000_000,
+			},
+			seconds:  day,
+			expected: 480_988_800,
+		},
+		{
+			name: "excess hits 0 during, current<target, day",
+			initial: ValidatorState{
+				Current:  9_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   Gas(6 * hour * 1_000),
+				MinFee:   2048,
+				K:        60_480_000_000,
+			},
+			seconds:  day,
+			expected: 176_947_200,
+		},
+		{
+			name: "excess=0, current>target, week",
+			initial: ValidatorState{
+				Current:  15_000,
+				Target:   10_000,
+				Capacity: 20_000,
+				Excess:   0,
+				MinFee:   2048,
+				K:        60_480_000_000,
+			},
+			seconds:  week,
+			expected: 1_269_816_464,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			actual := test.initial.CalculateContinuousFee(test.seconds)
+			require.Equal(t, test.expected, actual)
+		})
+	}
+}

vms/platformvm/block/codec.go

@@ -36,6 +36,7 @@ func init() {
 			txs.RegisterUnsignedTxsTypes(c),
 			RegisterBanffBlockTypes(c),
 			txs.RegisterDurangoUnsignedTxsTypes(c),
+			txs.RegisterEtnaUnsignedTxsTypes(c),
 		)
 	}
 

vms/platformvm/block/executor/block.go

@@ -29,25 +29,40 @@ func (*Block) ShouldVerifyWithContext(context.Context) (bool, error) {
 	return true, nil
 }
 
-func (b *Block) VerifyWithContext(_ context.Context, ctx *smblock.Context) error {
+func (b *Block) VerifyWithContext(ctx context.Context, smCtx *smblock.Context) error {
 	pChainHeight := uint64(0)
-	if ctx != nil {
-		pChainHeight = ctx.PChainHeight
+	if smCtx != nil {
+		pChainHeight = smCtx.PChainHeight
 	}
 
 	blkID := b.ID()
 	if blkState, ok := b.manager.blkIDToState[blkID]; ok {
 		if !blkState.verifiedHeights.Contains(pChainHeight) {
-			// PlatformVM blocks are currently valid regardless of the ProposerVM's
-			// PChainHeight. If this changes, those validity checks should be done prior
-			// to adding [pChainHeight] to [verifiedHeights].
+			if err := b.Visit(&warpBlockVerifier{
+				ctx:          ctx,
+				chainCtx:     b.manager.ctx,
+				state:        b.manager.state,
+				pChainHeight: pChainHeight,
+			}); err != nil {
+				return err
+			}
+
 			blkState.verifiedHeights.Add(pChainHeight)
 		}
 
 		// This block has already been verified.
 		return nil
 	}
 
+	if err := b.Visit(&warpBlockVerifier{
+		ctx:          ctx,
+		chainCtx:     b.manager.ctx,
+		state:        b.manager.state,
+		pChainHeight: pChainHeight,
+	}); err != nil {
+		return err
+	}
+
 	return b.Visit(&verifier{
 		backend:           b.manager.backend,
 		txExecutorBackend: b.manager.txExecutorBackend,