ACP-77: Implement RegisterSubnetValidatorTx

upgrade/upgrade.go

@@ -72,7 +72,7 @@ var (
 		DurangoTime:                  InitiallyActiveTime,
 		// Etna is left unactivated by default on local networks. It can be configured to
 		// activate by overriding the activation time in the upgrade file.
-		EtnaTime: UnscheduledActivationTime,
+		EtnaTime: InitiallyActiveTime,
 	}
 
 	ErrInvalidUpgradeTimes = errors.New("invalid upgrade configuration")

vms/platformvm/metrics/tx_metrics.go

@@ -132,16 +132,23 @@ func (m *txMetrics) TransferSubnetOwnershipTx(*txs.TransferSubnetOwnershipTx) er
 	return nil
 }
 
+func (m *txMetrics) BaseTx(*txs.BaseTx) error {
+	m.numTxs.With(prometheus.Labels{
+		txLabel: "base",
+	}).Inc()
+	return nil
+}
+
 func (m *txMetrics) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
 	m.numTxs.With(prometheus.Labels{
 		txLabel: "convert_subnet",
 	}).Inc()
 	return nil
 }
 
-func (m *txMetrics) BaseTx(*txs.BaseTx) error {
+func (m *txMetrics) RegisterSubnetValidatorTx(*txs.RegisterSubnetValidatorTx) error {
 	m.numTxs.With(prometheus.Labels{
-		txLabel: "base",
+		txLabel: "register_subnet_validator",
 	}).Inc()
 	return nil
 }

vms/platformvm/txs/codec.go

@@ -123,5 +123,6 @@ func RegisterDurangoTypes(targetCodec linearcodec.Codec) error {
 func RegisterEtnaTypes(targetCodec linearcodec.Codec) error {
 	return errors.Join(
 		targetCodec.RegisterType(&ConvertSubnetTx{}),
+		targetCodec.RegisterType(&RegisterSubnetValidatorTx{}),
 	)
 }

vms/platformvm/txs/executor/atomic_tx_executor.go

@@ -66,15 +66,15 @@ func (*AtomicTxExecutor) TransformSubnetTx(*txs.TransformSubnetTx) error {
 	return ErrWrongTxType
 }
 
-func (*AtomicTxExecutor) TransferSubnetOwnershipTx(*txs.TransferSubnetOwnershipTx) error {
+func (*AtomicTxExecutor) AddPermissionlessValidatorTx(*txs.AddPermissionlessValidatorTx) error {
 	return ErrWrongTxType
 }
 
-func (*AtomicTxExecutor) AddPermissionlessValidatorTx(*txs.AddPermissionlessValidatorTx) error {
+func (*AtomicTxExecutor) AddPermissionlessDelegatorTx(*txs.AddPermissionlessDelegatorTx) error {
 	return ErrWrongTxType
 }
 
-func (*AtomicTxExecutor) AddPermissionlessDelegatorTx(*txs.AddPermissionlessDelegatorTx) error {
+func (*AtomicTxExecutor) TransferSubnetOwnershipTx(*txs.TransferSubnetOwnershipTx) error {
 	return ErrWrongTxType
 }
 
@@ -86,6 +86,10 @@ func (*AtomicTxExecutor) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
 	return ErrWrongTxType
 }
 
+func (*AtomicTxExecutor) RegisterSubnetValidatorTx(*txs.RegisterSubnetValidatorTx) error {
+	return ErrWrongTxType
+}
+
 func (e *AtomicTxExecutor) ImportTx(tx *txs.ImportTx) error {
 	return e.atomicTx(tx)
 }

vms/platformvm/txs/executor/proposal_tx_executor.go

@@ -103,6 +103,10 @@ func (*ProposalTxExecutor) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
 	return ErrWrongTxType
 }
 
+func (*ProposalTxExecutor) RegisterSubnetValidatorTx(*txs.RegisterSubnetValidatorTx) error {
+	return ErrWrongTxType
+}
+
 func (e *ProposalTxExecutor) AddValidatorTx(tx *txs.AddValidatorTx) error {
 	// AddValidatorTx is a proposal transaction until the Banff fork
 	// activation. Following the activation, AddValidatorTxs must be issued into

vms/platformvm/txs/executor/standard_tx_executor.go

@@ -4,6 +4,7 @@
 package executor
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -15,15 +16,27 @@ import (
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+	"github.com/ava-labs/avalanchego/utils/hashing"
 	"github.com/ava-labs/avalanchego/utils/math"
 	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/vms/components/avax"
 	"github.com/ava-labs/avalanchego/vms/components/gas"
 	"github.com/ava-labs/avalanchego/vms/components/verify"
+	"github.com/ava-labs/avalanchego/vms/platformvm/signer"
 	"github.com/ava-labs/avalanchego/vms/platformvm/state"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
+	"github.com/ava-labs/avalanchego/vms/platformvm/warp"
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp/message"
+	"github.com/ava-labs/avalanchego/vms/platformvm/warp/payload"
+)
+
+const (
+	second                                = 1
+	minute                                = 60 * second
+	hour                                  = 60 * minute
+	day                                   = 24 * hour
+	RegisterSubnetValidatorTxExpiryWindow = day
 )
 
 var (
@@ -617,6 +630,169 @@ func (e *StandardTxExecutor) ConvertSubnetTx(tx *txs.ConvertSubnetTx) error {
 	return nil
 }
 
+func (e *StandardTxExecutor) RegisterSubnetValidatorTx(tx *txs.RegisterSubnetValidatorTx) error {
+	var (
+		currentTimestamp = e.State.GetTimestamp()
+		upgrades         = e.Backend.Config.UpgradeConfig
+	)
+	if !upgrades.IsEtnaActivated(currentTimestamp) {
+		return errEtnaUpgradeNotActive
+	}
+
+	if err := e.Tx.SyntacticVerify(e.Ctx); err != nil {
+		return err
+	}
+
+	if err := avax.VerifyMemoFieldLength(tx.Memo, true /*=isDurangoActive*/); err != nil {
+		return err
+	}
+
+	// Verify the flowcheck
+	fee, err := e.FeeCalculator.CalculateFee(tx)
+	if err != nil {
+		return err
+	}
+	fee, err = math.Add(fee, tx.Balance)
+	if err != nil {
+		return err
+	}
+
+	if err := e.Backend.FlowChecker.VerifySpend(
+		tx,
+		e.State,
+		tx.Ins,
+		tx.Outs,
+		e.Tx.Creds,
+		map[ids.ID]uint64{
+			e.Ctx.AVAXAssetID: fee,
+		},
+	); err != nil {
+		return err
+	}
+
+	warpMessage, err := warp.ParseMessage(tx.Message)
+	if err != nil {
+		return err
+	}
+	if warpMessage.NetworkID != e.Ctx.NetworkID {
+		return fmt.Errorf("expected networkID %d but got %d", e.Ctx.NetworkID, warpMessage.NetworkID)
+	}
+
+	addressedCall, err := payload.ParseAddressedCall(warpMessage.Payload)
+	if err != nil {
+		return err
+	}
+
+	msg, err := message.ParseRegisterSubnetValidator(addressedCall.Payload)
+	if err != nil {
+		return err
+	}
+	if err := msg.Verify(); err != nil {
+		return err
+	}
+
+	_, expectedChainID, expectedAddress, err := e.State.GetSubnetConversion(msg.SubnetID)
+	if err != nil {
+		return err
+	}
+	if warpMessage.SourceChainID != expectedChainID {
+		return fmt.Errorf("expected chainID %s but got %s", expectedChainID, warpMessage.SourceChainID)
+	}
+	if !bytes.Equal(addressedCall.SourceAddress, expectedAddress) {
+		return fmt.Errorf("expected address %s but got %s", expectedAddress, addressedCall.SourceAddress)
+	}
+
+	currentTimestampUnix := uint64(currentTimestamp.Unix())
+	if msg.Expiry <= currentTimestampUnix {
+		return fmt.Errorf("expected expiry to be after %d but got %d", currentTimestampUnix, msg.Expiry)
+	}
+	maxAllowedExpiry, err := math.Add(currentTimestampUnix, RegisterSubnetValidatorTxExpiryWindow)
+	if err != nil {
+		// This should never happen, as it would imply that either
+		// currentTimestampUnix or RegisterSubnetValidatorTxExpiryWindow is
+		// significantly larger than expected.
+		return err
+	}
+	if msg.Expiry > maxAllowedExpiry {
+		return fmt.Errorf("expected expiry to be before %d but got %d", maxAllowedExpiry, msg.Expiry)
+	}
+
+	pop := signer.ProofOfPossession{
+		PublicKey:         msg.BLSPublicKey,
+		ProofOfPossession: tx.ProofOfPossession,
+	}
+	if err := pop.Verify(); err != nil {
+		return err
+	}
+
+	validationID := hashing.ComputeHash256Array(addressedCall.Payload)
+	expiry := state.ExpiryEntry{
+		Timestamp:    msg.Expiry,
+		ValidationID: validationID,
+	}
+	isDuplicate, err := e.State.HasExpiry(expiry)
+	if err != nil {
+		return err
+	}
+	if isDuplicate {
+		return fmt.Errorf("expiry for %s already exists", validationID)
+	}
+
+	nodeID, err := ids.ToNodeID(msg.NodeID)
+	if err != nil {
+		return err
+	}
+
+	remainingBalanceOwner, err := txs.Codec.Marshal(txs.CodecVersion, &msg.RemainingBalanceOwner)
+	if err != nil {
+		return err
+	}
+
+	deactivationOwner, err := txs.Codec.Marshal(txs.CodecVersion, &msg.DisableOwner)
+	if err != nil {
+		return err
+	}
+
+	sov := state.SubnetOnlyValidator{
+		ValidationID:          validationID,
+		SubnetID:              msg.SubnetID,
+		NodeID:                nodeID,
+		PublicKey:             bls.PublicKeyToUncompressedBytes(pop.Key()),
+		RemainingBalanceOwner: remainingBalanceOwner,
+		DeactivationOwner:     deactivationOwner,
+		StartTime:             currentTimestampUnix,
+		Weight:                msg.Weight,
+		MinNonce:              0,
+		EndAccumulatedFee:     0, // If Balance is 0, this is 0
+	}
+	if tx.Balance != 0 {
+		// We are attempting to add an active validator
+		if gas.Gas(e.State.NumActiveSubnetOnlyValidators()) >= e.Backend.Config.ValidatorFeeCapacity {
+			return errMaxNumActiveValidators
+		}
+
+		currentFees := e.State.GetAccruedFees()
+		sov.EndAccumulatedFee, err = math.Add(tx.Balance, currentFees)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := e.State.PutSubnetOnlyValidator(sov); err != nil {
+		return err
+	}
+
+	txID := e.Tx.ID()
+
+	// Consume the UTXOS
+	avax.Consume(e.State, tx.Ins)
+	// Produce the UTXOS
+	avax.Produce(e.State, txID, tx.Outs)
+	// Prevent this warp message from being replayed
+	e.State.PutExpiry(expiry)
+	return nil
+}
+
 func (e *StandardTxExecutor) AddPermissionlessValidatorTx(tx *txs.AddPermissionlessValidatorTx) error {
 	if err := verifyAddPermissionlessValidatorTx(
 		e.Backend,

vms/platformvm/txs/fee/complexity.go

@@ -190,10 +190,19 @@ var (
 			ids.IDLen + // chainID
 			wrappers.IntLen + // address length
 			wrappers.IntLen + // validators length
-			wrappers.IntLen + // subnetAuth typeID
+			bls.SignatureLen + // proofOfPossession
 			wrappers.IntLen, // subnetAuthCredential typeID
 		gas.DBRead:  2, // subnet auth + manager lookup
 		gas.DBWrite: 2, // manager + weight
+		gas.Compute: 0, // TODO: Add compute complexity (and include the PoP compute)
+	}
+	IntrinsicRegisterSubnetValidatorTxComplexities = gas.Dimensions{
+		gas.Bandwidth: IntrinsicBaseTxComplexities[gas.Bandwidth] +
+			wrappers.LongLen + // balance
+			wrappers.IntLen + // signer typeID
+			wrappers.IntLen, // message length
+		gas.DBRead:  0, // TODO
+		gas.DBWrite: 0, // TODO
 		gas.Compute: 0,
 	}
 
@@ -433,6 +442,14 @@ func SignerComplexity(s signer.Signer) (gas.Dimensions, error) {
 	}
 }
 
+// WarpComplexity returns the complexity a warp message adds to a transaction.
+func WarpComplexity(message []byte) (gas.Dimensions, error) {
+	// TODO: Implement me
+	return gas.Dimensions{
+		gas.Bandwidth: uint64(len(message)),
+	}, nil
+}
+
 type complexityVisitor struct {
 	output gas.Dimensions
 }
@@ -683,6 +700,22 @@ func (c *complexityVisitor) ConvertSubnetTx(tx *txs.ConvertSubnetTx) error {
 	return err
 }
 
+func (c *complexityVisitor) RegisterSubnetValidatorTx(tx *txs.RegisterSubnetValidatorTx) error {
+	baseTxComplexity, err := baseTxComplexity(&tx.BaseTx)
+	if err != nil {
+		return err
+	}
+	warpComplexity, err := WarpComplexity(tx.Message)
+	if err != nil {
+		return err
+	}
+	c.output, err = IntrinsicConvertSubnetTxComplexities.Add(
+		&baseTxComplexity,
+		&warpComplexity,
+	)
+	return err
+}
+
 func baseTxComplexity(tx *txs.BaseTx) (gas.Dimensions, error) {
 	outputsComplexity, err := OutputComplexity(tx.Outs...)
 	if err != nil {

vms/platformvm/txs/fee/static_calculator.go

@@ -51,6 +51,10 @@ func (*staticVisitor) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
 	return ErrUnsupportedTx
 }
 
+func (*staticVisitor) RegisterSubnetValidatorTx(*txs.RegisterSubnetValidatorTx) error {
+	return ErrUnsupportedTx
+}
+
 func (c *staticVisitor) AddValidatorTx(*txs.AddValidatorTx) error {
 	c.fee = c.config.AddPrimaryNetworkValidatorFee
 	return nil