ConvertSubnetToL1 P Chain Tx

blockchain/helper.go

@@ -4,7 +4,10 @@
 package blockchain
 
 import (
+	"encoding/json"
+
 	"github.com/ava-labs/avalanchego/vms/platformvm"
+	"github.com/ava-labs/avalanchego/vms/platformvm/signer"
 
 	"github.com/ava-labs/avalanche-tooling-sdk-go/network"
 	"github.com/ava-labs/avalanche-tooling-sdk-go/utils"
@@ -19,3 +22,24 @@ func GetSubnet(subnetID ids.ID, network network.Network) (platformvm.GetSubnetCl
 	defer cancel()
 	return pClient.GetSubnet(ctx, subnetID)
 }
+
+func ConvertToBLSProofOfPossession(publicKey, proofOfPossesion string) (signer.ProofOfPossession, error) {
+	type jsonProofOfPossession struct {
+		PublicKey         string
+		ProofOfPossession string
+	}
+	jsonPop := jsonProofOfPossession{
+		PublicKey:         publicKey,
+		ProofOfPossession: proofOfPossesion,
+	}
+	popBytes, err := json.Marshal(jsonPop)
+	if err != nil {
+		return signer.ProofOfPossession{}, err
+	}
+	pop := &signer.ProofOfPossession{}
+	err = pop.UnmarshalJSON(popBytes)
+	if err != nil {
+		return signer.ProofOfPossession{}, err
+	}
+	return *pop, nil
+}

multisig/multisig.go

@@ -29,6 +29,7 @@ const (
 	PChainTransformSubnetTx
 	PChainAddPermissionlessValidatorTx
 	PChainTransferSubnetOwnershipTx
+	PChainConvertSubnetToL1Tx
 )
 
 type Multisig struct {
@@ -176,6 +177,8 @@ func (ms *Multisig) GetAuthSigners() ([]ids.ShortID, error) {
 		subnetAuth = unsignedTx.SubnetAuth
 	case *txs.TransferSubnetOwnershipTx:
 		subnetAuth = unsignedTx.SubnetAuth
+	case *txs.ConvertSubnetToL1Tx:
+		subnetAuth = unsignedTx.SubnetAuth
 	default:
 		return nil, fmt.Errorf("unexpected unsigned tx type %T", unsignedTx)
 	}
@@ -215,6 +218,8 @@ func (ms *Multisig) GetTxKind() (TxKind, error) {
 		return PChainAddPermissionlessValidatorTx, nil
 	case *txs.TransferSubnetOwnershipTx:
 		return PChainTransferSubnetOwnershipTx, nil
+	case *txs.ConvertSubnetToL1Tx:
+		return PChainConvertSubnetToL1Tx, nil
 	default:
 		return Undefined, fmt.Errorf("unexpected unsigned tx type %T", unsignedTx)
 	}
@@ -240,6 +245,8 @@ func (ms *Multisig) GetNetworkID() (uint32, error) {
 		networkID = unsignedTx.NetworkID
 	case *txs.TransferSubnetOwnershipTx:
 		networkID = unsignedTx.NetworkID
+	case *txs.ConvertSubnetToL1Tx:
+		networkID = unsignedTx.NetworkID
 	default:
 		return 0, fmt.Errorf("unexpected unsigned tx type %T", unsignedTx)
 	}
@@ -281,6 +288,8 @@ func (ms *Multisig) GetBlockchainID() (ids.ID, error) {
 		blockchainID = unsignedTx.BlockchainID
 	case *txs.TransferSubnetOwnershipTx:
 		blockchainID = unsignedTx.BlockchainID
+	case *txs.ConvertSubnetToL1Tx:
+		blockchainID = unsignedTx.BlockchainID
 	default:
 		return ids.Empty, fmt.Errorf("unexpected unsigned tx type %T", unsignedTx)
 	}
@@ -307,6 +316,8 @@ func (ms *Multisig) GetSubnetID() (ids.ID, error) {
 		subnetID = unsignedTx.Subnet
 	case *txs.TransferSubnetOwnershipTx:
 		subnetID = unsignedTx.Subnet
+	case *txs.ConvertSubnetToL1Tx:
+		subnetID = unsignedTx.Subnet
 	default:
 		return ids.Empty, fmt.Errorf("unexpected unsigned tx type %T", unsignedTx)
 	}

transactions/examples/convertSubnetToL1Tx.go

@@ -0,0 +1,148 @@
+// Copyright (C) 2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/ava-labs/avalanche-tooling-sdk-go/blockchain"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/keychain"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/network"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/transactions/p-chain/txs"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/wallet"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/formatting/address"
+	avagoTxs "github.com/ava-labs/avalanchego/vms/platformvm/txs"
+	"github.com/ava-labs/avalanchego/vms/platformvm/warp/message"
+	"github.com/ava-labs/avalanchego/wallet/subnet/primary"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func ConvertL1() error {
+	// Configuration - Replace these with your actual values
+	const (
+		// Your private key file path
+		privateKeyFilePath = ""
+
+		// Subnet and Chain IDs
+		subnetIDStr = ""
+		chainIDStr  = ""
+
+		// Validator information
+		nodeIDStr            = ""
+		BLSPublicKey         = "0x..."     // Replace with actual BLS public key
+		BLSProofOfPossession = "0x..."     // Replace with actual BLS proof
+		ChangeOwnerAddr      = "P-fujixxx" // Address to receive remaining balance
+		Weight               = 100         // Validator weight
+		Balance              = 1000000000  // Validator balance in nAVAX
+
+		// Validator manager contract address
+		validatorManagerAddr = "0x0FEEDC0DE0000000000000000000000000000000" // Replace with actual contract address
+	)
+
+	// Subnet auth keys (addresses that can sign the conversion tx)
+	subnetAuthKeysStrs := []string{
+		"P-fujixxx", // Replace with actual addresses
+	}
+
+	network := network.FujiNetwork()
+	keychain, err := keychain.NewKeychain(network, privateKeyFilePath, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create keychain: %w", err)
+	}
+
+	// Parse IDs
+	subnetID, err := ids.FromString(subnetIDStr)
+	if err != nil {
+		return fmt.Errorf("failed to parse subnet ID: %w", err)
+	}
+
+	chainID, err := ids.FromString(chainIDStr)
+	if err != nil {
+		return fmt.Errorf("failed to parse chain ID: %w", err)
+	}
+
+	deployer := txs.NewPublicDeployer(keychain, network)
+
+	wallet, err := wallet.New(
+		context.Background(),
+		network.Endpoint,
+		keychain.Keychain,
+		primary.WalletConfig{
+			SubnetIDs: []ids.ID{subnetID},
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("failed to create wallet: %w", err)
+	}
+
+	subnetAuthKeys, err := address.ParseToIDs(subnetAuthKeysStrs)
+	if err != nil {
+		return fmt.Errorf("failure parsing auth keys: %w", err)
+	}
+
+	bootstrapValidators := []*avagoTxs.ConvertSubnetToL1Validator{}
+	nodeID, err := ids.NodeIDFromString(nodeIDStr)
+	if err != nil {
+		return fmt.Errorf("failed to parse node ID: %w", err)
+	}
+
+	blsInfo, err := blockchain.ConvertToBLSProofOfPossession(BLSPublicKey, BLSProofOfPossession)
+	if err != nil {
+		return fmt.Errorf("failure parsing BLS info: %w", err)
+	}
+
+	addrs, err := address.ParseToIDs([]string{ChangeOwnerAddr})
+	if err != nil {
+		return fmt.Errorf("failure parsing change owner address: %w", err)
+	}
+
+	bootstrapValidator := &avagoTxs.ConvertSubnetToL1Validator{
+		NodeID:  nodeID[:],
+		Weight:  Weight,
+		Balance: Balance,
+		Signer:  blsInfo,
+		RemainingBalanceOwner: message.PChainOwner{
+			Threshold: 1,
+			Addresses: addrs,
+		},
+	}
+	bootstrapValidators = append(bootstrapValidators, bootstrapValidator)
+
+	convertSubnetParams := txs.ConvertSubnetToL1TxParams{
+		// SubnetAuthKeys are the keys used to sign `ConvertSubnetToL1Tx`
+		SubnetAuthKeys: subnetAuthKeys,
+		// SubnetID is Subnet ID of the subnet to convert to an L1.
+		SubnetID: subnetID,
+		// ChainID is Blockchain ID of the L1 where the validator manager contract is deployed.
+		ChainID: chainID,
+		// Address is address of the validator manager contract.
+		Address: common.HexToAddress(validatorManagerAddr).Bytes(),
+		// Validators are the initial set of L1 validators after the conversion.
+		Validators: bootstrapValidators,
+		// Wallet is the wallet used to sign `ConvertSubnetToL1Tx`
+		Wallet: &wallet, // Use the wallet wrapper
+	}
+
+	tx, err := deployer.NewConvertSubnetToL1Tx(convertSubnetParams)
+	if err != nil {
+		return fmt.Errorf("failed to create convert subnet tx: %w", err)
+	}
+
+	// Since it has the required signatures, we will now commit the transaction on chain
+	txID, err := deployer.Commit(*tx, wallet, true)
+	if err != nil {
+		return fmt.Errorf("failed to commit transaction: %w", err)
+	}
+	fmt.Printf("Convert subnet to L1 transaction submitted successfully! TX ID: %s\n", txID.String())
+	return nil
+}
+
+func main() {
+	if err := ConvertL1(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}

transactions/p-chain/txs/baseTx.go

@@ -0,0 +1,49 @@
+// Copyright (C) 2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+package txs
+
+import (
+	"errors"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/set"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+	"github.com/ava-labs/avalanchego/wallet/subnet/primary/common"
+
+	"github.com/ava-labs/avalanche-tooling-sdk-go/keychain"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/network"
+	"github.com/ava-labs/avalanchego/wallet/subnet/primary"
+)
+
+var ErrNoSubnetAuthKeysInWallet = errors.New("auth wallet does not contain auth keys")
+
+type PublicDeployer struct {
+	kc      *keychain.Keychain
+	network network.Network
+	wallet  *primary.Wallet
+}
+
+func NewPublicDeployer(kc *keychain.Keychain, network network.Network) *PublicDeployer {
+	return &PublicDeployer{
+		kc:      kc,
+		network: network,
+	}
+}
+
+func (d *PublicDeployer) getMultisigTxOptions(subnetAuthKeys []ids.ShortID) []common.Option {
+	options := []common.Option{}
+	walletAddrs := d.kc.Addresses().List()
+	changeAddr := walletAddrs[0]
+	// addrs to use for signing
+	customAddrsSet := set.Set[ids.ShortID]{}
+	customAddrsSet.Add(walletAddrs...)
+	customAddrsSet.Add(subnetAuthKeys...)
+	options = append(options, common.WithCustomAddresses(customAddrsSet))
+	// set change to go to wallet addr (instead of any other subnet auth key)
+	changeOwner := &secp256k1fx.OutputOwners{
+		Threshold: 1,
+		Addrs:     []ids.ShortID{changeAddr},
+	}
+	options = append(options, common.WithChangeOwner(changeOwner))
+	return options
+}

transactions/p-chain/txs/convertSubnetToL1Tx.go

@@ -0,0 +1,49 @@
+// Copyright (C) 2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+package txs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ava-labs/avalanche-tooling-sdk-go/multisig"
+	"github.com/ava-labs/avalanche-tooling-sdk-go/wallet"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
+)
+
+// ConvertSubnetToL1TxParams contains all parameters needed to create a ConvertSubnetToL1Tx
+type ConvertSubnetToL1TxParams struct {
+	// SubnetAuthKeys are the keys used to sign `ConvertSubnetToL1Tx`
+	SubnetAuthKeys []ids.ShortID
+	// SubnetID is Subnet ID of the subnet to convert to an L1.
+	SubnetID ids.ID
+	// ChainID is Blockchain ID of the L1 where the validator manager contract is deployed.
+	ChainID ids.ID
+	// Address is address of the validator manager contract.
+	Address []byte
+	// Validators are the initial set of L1 validators after the conversion.
+	Validators []*txs.ConvertSubnetToL1Validator
+	// Wallet is the wallet used to sign `ConvertSubnetToL1Tx`
+	Wallet *wallet.Wallet
+}
+
+func (d *PublicDeployer) NewConvertSubnetToL1Tx(params ConvertSubnetToL1TxParams) (*multisig.Multisig, error) {
+	options := d.getMultisigTxOptions(params.SubnetAuthKeys)
+	unsignedTx, err := params.Wallet.P().Builder().NewConvertSubnetToL1Tx(
+		params.SubnetID,
+		params.ChainID,
+		params.Address,
+		params.Validators,
+		options...,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error building tx: %w", err)
+	}
+	tx := txs.Tx{Unsigned: unsignedTx}
+	if err := params.Wallet.P().Signer().Sign(context.Background(), &tx); err != nil {
+		return nil, fmt.Errorf("error signing tx: %w", err)
+	}
+	return multisig.New(&tx), nil
+}