Merge branch 'master' into update-versions-v1.12.0

api/info/service.md

@@ -512,7 +512,6 @@ info.peers({
     lastReceived: string,
     benched: string[],
     observedUptime: int,
-    observedSubnetUptime: map[string]int,
   }
 }
 ```
@@ -558,7 +557,6 @@ curl -X POST --data '{
         "lastReceived": "2020-06-01T15:22:57Z",
         "benched": [],
         "observedUptime": "99",
-        "observedSubnetUptimes": {},
         "trackedSubnets": [],
         "benched": []
       },

vms/example/xsvm/cmd/chain/create/cmd.go

@@ -38,14 +38,13 @@ func createFunc(c *cobra.Command, args []string) error {
 	ctx := c.Context()
 	kc := secp256k1fx.NewKeychain(config.PrivateKey)
 
-	// NewWalletFromURI fetches the available UTXOs owned by [kc] on the network
-	// that [uri] is hosting.
+	// MakePWallet fetches the available UTXOs owned by [kc] on the P-chain that
+	// [uri] is hosting.
 	walletSyncStartTime := time.Now()
-	wallet, err := primary.MakeWallet(
+	wallet, err := primary.MakePWallet(
 		ctx,
 		config.URI,
 		kc,
-		kc,
 		primary.WalletConfig{
 			SubnetIDs: []ids.ID{config.SubnetID},
 		},
@@ -55,9 +54,6 @@ func createFunc(c *cobra.Command, args []string) error {
 	}
 	log.Printf("synced wallet in %s\n", time.Since(walletSyncStartTime))
 
-	// Get the P-chain wallet
-	pWallet := wallet.P()
-
 	genesisBytes, err := genesis.Codec.Marshal(genesis.CodecVersion, &genesis.Genesis{
 		Timestamp: 0,
 		Allocations: []genesis.Allocation{
@@ -72,7 +68,7 @@ func createFunc(c *cobra.Command, args []string) error {
 	}
 
 	createChainStartTime := time.Now()
-	createChainTxID, err := pWallet.IssueCreateChainTx(
+	createChainTxID, err := wallet.IssueCreateChainTx(
 		config.SubnetID,
 		genesisBytes,
 		constants.XSVMID,

vms/platformvm/block/executor/manager.go

@@ -23,7 +23,8 @@ import (
 var (
 	_ Manager = (*manager)(nil)
 
-	ErrChainNotSynced = errors.New("chain not synced")
+	ErrChainNotSynced              = errors.New("chain not synced")
+	ErrImportTxWhilePartialSyncing = errors.New("issuing an import tx is not allowed while partial syncing")
 )
 
 type Manager interface {
@@ -124,6 +125,15 @@ func (m *manager) VerifyTx(tx *txs.Tx) error {
 		return ErrChainNotSynced
 	}
 
+	// If partial sync is enabled, this node isn't guaranteed to have the full
+	// UTXO set from shared memory. To avoid issuing invalid transactions,
+	// issuance of an ImportTx during this state is completely disallowed.
+	if m.txExecutorBackend.Config.PartialSyncPrimaryNetwork {
+		if _, isImportTx := tx.Unsigned.(*txs.ImportTx); isImportTx {
+			return ErrImportTxWhilePartialSyncing
+		}
+	}
+
 	recommendedPChainHeight, err := m.ctx.ValidatorState.GetMinimumHeight(context.TODO())
 	if err != nil {
 		return fmt.Errorf("failed to fetch P-chain height: %w", err)

vms/platformvm/client.go

@@ -687,3 +687,29 @@ func GetDeactivationOwners(
 	}
 	return deactivationOwners, nil
 }
+
+// GetOwners returns the union of GetSubnetOwners and GetDeactivationOwners.
+func GetOwners(
+	c Client,
+	ctx context.Context,
+	subnetIDs []ids.ID,
+	validationIDs []ids.ID,
+) (map[ids.ID]fx.Owner, error) {
+	subnetOwners, err := GetSubnetOwners(c, ctx, subnetIDs...)
+	if err != nil {
+		return nil, err
+	}
+	deactivationOwners, err := GetDeactivationOwners(c, ctx, validationIDs...)
+	if err != nil {
+		return nil, err
+	}
+
+	owners := make(map[ids.ID]fx.Owner, len(subnetOwners)+len(deactivationOwners))
+	for id, owner := range subnetOwners {
+		owners[id] = owner
+	}
+	for id, owner := range deactivationOwners {
+		owners[id] = owner
+	}
+	return owners, nil
+}

vms/platformvm/network/network.go

@@ -5,7 +5,6 @@ package network
 
 import (
 	"context"
-	"errors"
 	"sync"
 	"time"
 
@@ -26,8 +25,6 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp"
 )
 
-var errMempoolDisabledWithPartialSync = errors.New("mempool is disabled partial syncing")
-
 type Network struct {
 	*p2p.Network
 
@@ -188,18 +185,12 @@ func New(
 }
 
 func (n *Network) PushGossip(ctx context.Context) {
-	// TODO: Even though the node is running partial sync, we should support
-	// issuing transactions from the RPC.
-	if n.partialSyncPrimaryNetwork {
-		return
-	}
-
 	gossip.Every(ctx, n.log, n.txPushGossiper, n.txPushGossipFrequency)
 }
 
 func (n *Network) PullGossip(ctx context.Context) {
-	// If the node is running partial sync, we should not perform any pull
-	// gossip.
+	// If the node is running partial sync, we do not perform any pull gossip
+	// because we should never be a validator.
 	if n.partialSyncPrimaryNetwork {
 		return
 	}
@@ -219,15 +210,6 @@ func (n *Network) AppGossip(ctx context.Context, nodeID ids.NodeID, msgBytes []b
 }
 
 func (n *Network) IssueTxFromRPC(tx *txs.Tx) error {
-	// If we are partially syncing the Primary Network, we should not be
-	// maintaining the transaction mempool locally.
-	//
-	// TODO: We should still push the transaction to some peers when partial
-	// syncing.
-	if n.partialSyncPrimaryNetwork {
-		return errMempoolDisabledWithPartialSync
-	}
-
 	if err := n.mempool.Add(tx); err != nil {
 		return err
 	}

vms/platformvm/network/network_test.go

@@ -62,12 +62,11 @@ func TestNetworkIssueTxFromRPC(t *testing.T) {
 	tx := &txs.Tx{}
 
 	type test struct {
-		name                      string
-		mempoolFunc               func(*gomock.Controller) pmempool.Mempool
-		txVerifier                testTxVerifier
-		partialSyncPrimaryNetwork bool
-		appSenderFunc             func(*gomock.Controller) common.AppSender
-		expectedErr               error
+		name          string
+		mempoolFunc   func(*gomock.Controller) pmempool.Mempool
+		txVerifier    testTxVerifier
+		appSenderFunc func(*gomock.Controller) common.AppSender
+		expectedErr   error
 	}
 
 	tests := []test{
@@ -129,17 +128,6 @@ func TestNetworkIssueTxFromRPC(t *testing.T) {
 			},
 			expectedErr: errTest,
 		},
-		{
-			name: "mempool is disabled if primary network is not being fully synced",
-			mempoolFunc: func(ctrl *gomock.Controller) pmempool.Mempool {
-				return mempoolmock.NewMempool(ctrl)
-			},
-			partialSyncPrimaryNetwork: true,
-			appSenderFunc: func(ctrl *gomock.Controller) common.AppSender {
-				return commonmock.NewSender(ctrl)
-			},
-			expectedErr: errMempoolDisabledWithPartialSync,
-		},
 		{
 			name: "happy path",
 			mempoolFunc: func(ctrl *gomock.Controller) pmempool.Mempool {
@@ -174,7 +162,7 @@ func TestNetworkIssueTxFromRPC(t *testing.T) {
 				snowCtx.ValidatorState,
 				tt.txVerifier,
 				tt.mempoolFunc(ctrl),
-				tt.partialSyncPrimaryNetwork,
+				false,
 				tt.appSenderFunc(ctrl),
 				nil,
 				nil,

wallet/chain/p/context.go

@@ -7,7 +7,7 @@ import (
 	"context"
 
 	"github.com/ava-labs/avalanchego/api/info"
-	"github.com/ava-labs/avalanchego/vms/avm"
+	"github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/vms/platformvm"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 	"github.com/ava-labs/avalanchego/wallet/chain/p/builder"
@@ -21,42 +21,40 @@ const gasPriceMultiplier = 2
 
 func NewContextFromURI(ctx context.Context, uri string) (*builder.Context, error) {
 	infoClient := info.NewClient(uri)
-	xChainClient := avm.NewClient(uri, "X")
-	pChainClient := platformvm.NewClient(uri)
-	return NewContextFromClients(ctx, infoClient, xChainClient, pChainClient)
+	chainClient := platformvm.NewClient(uri)
+	return NewContextFromClients(ctx, infoClient, chainClient)
 }
 
 func NewContextFromClients(
 	ctx context.Context,
 	infoClient info.Client,
-	xChainClient avm.Client,
-	pChainClient platformvm.Client,
+	chainClient platformvm.Client,
 ) (*builder.Context, error) {
 	networkID, err := infoClient.GetNetworkID(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	asset, err := xChainClient.GetAssetDescription(ctx, "AVAX")
+	avaxAssetID, err := chainClient.GetStakingAssetID(ctx, constants.PrimaryNetworkID)
 	if err != nil {
 		return nil, err
 	}
 
-	dynamicFeeConfig, err := pChainClient.GetFeeConfig(ctx)
+	dynamicFeeConfig, err := chainClient.GetFeeConfig(ctx)
 	if err != nil {
 		return nil, err
 	}
 
 	// TODO: After Etna is activated, assume the gas price is always non-zero.
 	if dynamicFeeConfig.MinPrice != 0 {
-		_, gasPrice, _, err := pChainClient.GetFeeState(ctx)
+		_, gasPrice, _, err := chainClient.GetFeeState(ctx)
 		if err != nil {
 			return nil, err
 		}
 
 		return &builder.Context{
 			NetworkID:         networkID,
-			AVAXAssetID:       asset.AssetID,
+			AVAXAssetID:       avaxAssetID,
 			ComplexityWeights: dynamicFeeConfig.Weights,
 			GasPrice:          gasPriceMultiplier * gasPrice,
 		}, nil
@@ -69,7 +67,7 @@ func NewContextFromClients(
 
 	return &builder.Context{
 		NetworkID:   networkID,
-		AVAXAssetID: asset.AssetID,
+		AVAXAssetID: avaxAssetID,
 		StaticFeeConfig: fee.StaticConfig{
 			TxFee:                         uint64(staticFeeConfig.TxFee),
 			CreateSubnetTxFee:             uint64(staticFeeConfig.CreateSubnetTxFee),

wallet/subnet/primary/api.go

@@ -80,7 +80,7 @@ func FetchState(
 	xClient := avm.NewClient(uri, "X")
 	cClient := evm.NewCChainClient(uri)
 
-	pCTX, err := p.NewContextFromClients(ctx, infoClient, xClient, pClient)
+	pCTX, err := p.NewContextFromClients(ctx, infoClient, pClient)
 	if err != nil {
 		return nil, err
 	}
@@ -145,6 +145,38 @@ func FetchState(
 	}, nil
 }
 
+func FetchPState(
+	ctx context.Context,
+	uri string,
+	addrs set.Set[ids.ShortID],
+) (
+	platformvm.Client,
+	*pbuilder.Context,
+	walletcommon.UTXOs,
+	error,
+) {
+	infoClient := info.NewClient(uri)
+	chainClient := platformvm.NewClient(uri)
+
+	context, err := p.NewContextFromClients(ctx, infoClient, chainClient)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	utxos := walletcommon.NewUTXOs()
+	addrList := addrs.List()
+	err = AddAllUTXOs(
+		ctx,
+		utxos,
+		chainClient,
+		txs.Codec,
+		constants.PlatformChainID,
+		constants.PlatformChainID,
+		addrList,
+	)
+	return chainClient, context, utxos, err
+}
+
 type EthState struct {
 	Client   ethclient.Client
 	Accounts map[ethcommon.Address]*c.Account

wallet/subnet/primary/examples/add-permissioned-subnet-validator/main.go

@@ -41,14 +41,13 @@ func main() {
 	}
 	log.Printf("fetched node ID %s in %s\n", nodeID, time.Since(nodeInfoStartTime))
 
-	// MakeWallet fetches the available UTXOs owned by [kc] on the network that
+	// MakePWallet fetches the available UTXOs owned by [kc] on the P-chain that
 	// [uri] is hosting and registers [subnetID].
 	walletSyncStartTime := time.Now()
-	wallet, err := primary.MakeWallet(
+	wallet, err := primary.MakePWallet(
 		ctx,
 		uri,
 		kc,
-		kc,
 		primary.WalletConfig{
 			SubnetIDs: []ids.ID{subnetID},
 		},
@@ -58,11 +57,8 @@ func main() {
 	}
 	log.Printf("synced wallet in %s\n", time.Since(walletSyncStartTime))
 
-	// Get the P-chain wallet
-	pWallet := wallet.P()
-
 	addValidatorStartTime := time.Now()
-	addValidatorTx, err := pWallet.IssueAddSubnetValidatorTx(&txs.SubnetValidator{
+	addValidatorTx, err := wallet.IssueAddSubnetValidatorTx(&txs.SubnetValidator{
 		Validator: txs.Validator{
 			NodeID: nodeID,
 			Start:  uint64(startTime.Unix()),

wallet/subnet/primary/examples/add-primary-validator/main.go

@@ -39,37 +39,33 @@ func main() {
 	}
 	log.Printf("fetched node ID %s in %s\n", nodeID, time.Since(nodeInfoStartTime))
 
-	// MakeWallet fetches the available UTXOs owned by [kc] on the network that
+	// MakePWallet fetches the available UTXOs owned by [kc] on the P-chain that
 	// [uri] is hosting.
 	walletSyncStartTime := time.Now()
-	wallet, err := primary.MakeWallet(
+	wallet, err := primary.MakePWallet(
 		ctx,
 		uri,
 		kc,
-		kc,
 		primary.WalletConfig{},
 	)
 	if err != nil {
 		log.Fatalf("failed to initialize wallet: %s\n", err)
 	}
 	log.Printf("synced wallet in %s\n", time.Since(walletSyncStartTime))
 
-	// Get the P-chain wallet
-	pWallet := wallet.P()
-	pBuilder := pWallet.Builder()
-	pContext := pBuilder.Context()
-	avaxAssetID := pContext.AVAXAssetID
+	// Get the chain context
+	context := wallet.Builder().Context()
 
 	addValidatorStartTime := time.Now()
-	addValidatorTx, err := pWallet.IssueAddPermissionlessValidatorTx(
+	addValidatorTx, err := wallet.IssueAddPermissionlessValidatorTx(
 		&txs.SubnetValidator{Validator: txs.Validator{
 			NodeID: nodeID,
 			Start:  uint64(startTime.Unix()),
 			End:    uint64(startTime.Add(duration).Unix()),
 			Wght:   weight,
 		}},
 		nodePOP,
-		avaxAssetID,
+		context.AVAXAssetID,
 		&secp256k1fx.OutputOwners{
 			Threshold: 1,
 			Addrs:     []ids.ShortID{validatorRewardAddr},