From 870067a6c13a377ba347ce9aa4ae2920d9b0d6f0 Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Tue, 28 May 2024 12:18:20 -0400
Subject: [PATCH 1/7] [vms/platformvm] Return correct owner in `GetSubnets`
 after transfer

---
 vms/platformvm/service.go      | 21 ++++++++++----
 vms/platformvm/service_test.go | 50 ++++++++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/vms/platformvm/service.go b/vms/platformvm/service.go
index dfe970a88b0a..0d7f6470e701 100644
--- a/vms/platformvm/service.go
+++ b/vms/platformvm/service.go
@@ -544,15 +544,26 @@ func (s *Service) GetSubnets(_ *http.Request, args *GetSubnetsArgs, response *Ge
 				continue
 			}
 
-			unsignedTx := subnet.Unsigned.(*txs.CreateSubnetTx)
-			owner := unsignedTx.Owner.(*secp256k1fx.OutputOwners)
-			controlAddrs := []string{}
-			for _, controlKeyID := range owner.Addrs {
+			subnetOwner, err := s.vm.state.GetSubnetOwner(subnetID)
+			if err == database.ErrNotFound {
+				continue
+			}
+			if err != nil {
+				return err
+			}
+
+			owner, ok := subnetOwner.(*secp256k1fx.OutputOwners)
+			if !ok {
+				return fmt.Errorf("expected *secp256k1fx.OutputOwners but got %T", subnetOwner)
+			}
+
+			controlAddrs := make([]string, len(owner.Addrs))
+			for i, controlKeyID := range owner.Addrs {
 				addr, err := s.addrManager.FormatLocalAddress(controlKeyID)
 				if err != nil {
 					return fmt.Errorf("problem formatting address: %w", err)
 				}
-				controlAddrs = append(controlAddrs, addr)
+				controlAddrs[i] = addr
 			}
 			response.Subnets[i] = APISubnet{
 				ID:          subnetID,
diff --git a/vms/platformvm/service_test.go b/vms/platformvm/service_test.go
index 95e2f98c3228..d72e11f6379c 100644
--- a/vms/platformvm/service_test.go
+++ b/vms/platformvm/service_test.go
@@ -1041,3 +1041,53 @@ func TestServiceGetBlockByHeight(t *testing.T) {
 		})
 	}
 }
+
+func TestServiceGetSubnets(t *testing.T) {
+	require := require.New(t)
+	service, _, _ := defaultService(t)
+
+	testSubnet1ID := testSubnet1.ID()
+
+	var response GetSubnetsResponse
+	require.NoError(service.GetSubnets(nil, &GetSubnetsArgs{}, &response))
+	require.Equal([]APISubnet{
+		{
+			ID: testSubnet1ID,
+			ControlKeys: []string{
+				"P-testing1d6kkj0qh4wcmus3tk59npwt3rluc6en72ngurd",
+				"P-testing17fpqs358de5lgu7a5ftpw2t8axf0pm33983krk",
+				"P-testing1lnk637g0edwnqc2tn8tel39652fswa3xk4r65e",
+			},
+			Threshold: 2,
+		},
+		{
+			ID:          constants.PrimaryNetworkID,
+			ControlKeys: []string{},
+			Threshold:   0,
+		},
+	}, response.Subnets)
+
+	newOwnerIDStr := "P-testing1t73fa4p4dypa4s3kgufuvr6hmprjclw66mgqgm"
+	newOwnerID, err := service.addrManager.ParseLocalAddress(newOwnerIDStr)
+	require.NoError(err)
+	service.vm.state.SetSubnetOwner(testSubnet1ID, &secp256k1fx.OutputOwners{
+		Addrs:     []ids.ShortID{newOwnerID},
+		Threshold: 1,
+	})
+
+	require.NoError(service.GetSubnets(nil, &GetSubnetsArgs{}, &response))
+	require.Equal([]APISubnet{
+		{
+			ID: testSubnet1ID,
+			ControlKeys: []string{
+				newOwnerIDStr,
+			},
+			Threshold: 1,
+		},
+		{
+			ID:          constants.PrimaryNetworkID,
+			ControlKeys: []string{},
+			Threshold:   0,
+		},
+	}, response.Subnets)
+}

From 6b51777bbf69e8f56626a318a573a071b024a9b7 Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Tue, 28 May 2024 11:46:22 -0400
Subject: [PATCH 2/7] save

---
 vms/platformvm/service.go          | 14 ++++-----
 vms/platformvm/state/diff_test.go  | 18 ++++++------
 vms/platformvm/state/mock_state.go | 30 +++++++++----------
 vms/platformvm/state/state.go      | 46 ++++++++++++++----------------
 vms/platformvm/vm.go               |  6 ++--
 vms/platformvm/vm_test.go          |  6 ++--
 6 files changed, 58 insertions(+), 62 deletions(-)

diff --git a/vms/platformvm/service.go b/vms/platformvm/service.go
index 0d7f6470e701..66284b7de693 100644
--- a/vms/platformvm/service.go
+++ b/vms/platformvm/service.go
@@ -527,14 +527,13 @@ func (s *Service) GetSubnets(_ *http.Request, args *GetSubnetsArgs, response *Ge
 
 	getAll := len(args.IDs) == 0
 	if getAll {
-		subnets, err := s.vm.state.GetSubnets() // all subnets
+		subnetIDs, err := s.vm.state.GetSubnetIDs() // all subnets
 		if err != nil {
 			return fmt.Errorf("error getting subnets from database: %w", err)
 		}
 
-		response.Subnets = make([]APISubnet, len(subnets)+1)
-		for i, subnet := range subnets {
-			subnetID := subnet.ID()
+		response.Subnets = make([]APISubnet, len(subnetIDs)+1)
+		for i, subnetID := range subnetIDs {
 			if _, err := s.vm.state.GetSubnetTransformation(subnetID); err == nil {
 				response.Subnets[i] = APISubnet{
 					ID:          subnetID,
@@ -572,7 +571,7 @@ func (s *Service) GetSubnets(_ *http.Request, args *GetSubnetsArgs, response *Ge
 			}
 		}
 		// Include primary network
-		response.Subnets[len(subnets)] = APISubnet{
+		response.Subnets[len(subnetIDs)] = APISubnet{
 			ID:          constants.PrimaryNetworkID,
 			ControlKeys: []string{},
 			Threshold:   avajson.Uint32(0),
@@ -1237,14 +1236,13 @@ func (s *Service) GetBlockchains(_ *http.Request, _ *struct{}, response *GetBloc
 	s.vm.ctx.Lock.Lock()
 	defer s.vm.ctx.Lock.Unlock()
 
-	subnets, err := s.vm.state.GetSubnets()
+	subnetIDs, err := s.vm.state.GetSubnetIDs()
 	if err != nil {
 		return fmt.Errorf("couldn't retrieve subnets: %w", err)
 	}
 
 	response.Blockchains = []APIBlockchain{}
-	for _, subnet := range subnets {
-		subnetID := subnet.ID()
+	for _, subnetID := range subnetIDs {
 		chains, err := s.vm.state.GetChains(subnetID)
 		if err != nil {
 			return fmt.Errorf(
diff --git a/vms/platformvm/state/diff_test.go b/vms/platformvm/state/diff_test.go
index 87fd59714029..0f65b0936113 100644
--- a/vms/platformvm/state/diff_test.go
+++ b/vms/platformvm/state/diff_test.go
@@ -260,11 +260,11 @@ func TestDiffSubnet(t *testing.T) {
 	state.AddSubnet(parentStateCreateSubnetTx)
 
 	// Verify parent returns one subnet
-	subnets, err := state.GetSubnets()
+	subnetIDs, err := state.GetSubnetIDs()
 	require.NoError(err)
-	require.Equal([]*txs.Tx{
-		parentStateCreateSubnetTx,
-	}, subnets)
+	require.Equal([]ids.ID{
+		parentStateCreateSubnetTx.ID(),
+	}, subnetIDs)
 
 	states := NewMockVersions(ctrl)
 	lastAcceptedID := ids.GenerateTestID()
@@ -285,12 +285,12 @@ func TestDiffSubnet(t *testing.T) {
 	require.NoError(diff.Apply(state))
 
 	// Verify parent now returns two subnets
-	subnets, err = state.GetSubnets()
+	subnetIDs, err = state.GetSubnetIDs()
 	require.NoError(err)
-	require.Equal([]*txs.Tx{
-		parentStateCreateSubnetTx,
-		createSubnetTx,
-	}, subnets)
+	require.Equal([]ids.ID{
+		parentStateCreateSubnetTx.ID(),
+		createSubnetTx.ID(),
+	}, subnetIDs)
 }
 
 func TestDiffChain(t *testing.T) {
diff --git a/vms/platformvm/state/mock_state.go b/vms/platformvm/state/mock_state.go
index 201c5ef7c5fd..38203c5a5b43 100644
--- a/vms/platformvm/state/mock_state.go
+++ b/vms/platformvm/state/mock_state.go
@@ -1410,6 +1410,21 @@ func (mr *MockStateMockRecorder) GetStatelessBlock(arg0 any) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessBlock", reflect.TypeOf((*MockState)(nil).GetStatelessBlock), arg0)
 }
 
+// GetSubnetIDs mocks base method.
+func (m *MockState) GetSubnetIDs() ([]ids.ID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSubnetIDs")
+	ret0, _ := ret[0].([]ids.ID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSubnetIDs indicates an expected call of GetSubnetIDs.
+func (mr *MockStateMockRecorder) GetSubnetIDs() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetIDs", reflect.TypeOf((*MockState)(nil).GetSubnetIDs))
+}
+
 // GetSubnetOwner mocks base method.
 func (m *MockState) GetSubnetOwner(arg0 ids.ID) (fx.Owner, error) {
 	m.ctrl.T.Helper()
@@ -1440,21 +1455,6 @@ func (mr *MockStateMockRecorder) GetSubnetTransformation(arg0 any) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetTransformation", reflect.TypeOf((*MockState)(nil).GetSubnetTransformation), arg0)
 }
 
-// GetSubnets mocks base method.
-func (m *MockState) GetSubnets() ([]*txs.Tx, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSubnets")
-	ret0, _ := ret[0].([]*txs.Tx)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetSubnets indicates an expected call of GetSubnets.
-func (mr *MockStateMockRecorder) GetSubnets() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnets", reflect.TypeOf((*MockState)(nil).GetSubnets))
-}
-
 // GetTimestamp mocks base method.
 func (m *MockState) GetTimestamp() time.Time {
 	m.ctrl.T.Helper()
diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go
index 7f06f02e86d6..41244ef3df1e 100644
--- a/vms/platformvm/state/state.go
+++ b/vms/platformvm/state/state.go
@@ -134,7 +134,7 @@ type State interface {
 	GetBlockIDAtHeight(height uint64) (ids.ID, error)
 
 	GetRewardUTXOs(txID ids.ID) ([]*avax.UTXO, error)
-	GetSubnets() ([]*txs.Tx, error)
+	GetSubnetIDs() ([]ids.ID, error)
 	GetChains(subnetID ids.ID) ([]*txs.Tx, error)
 
 	// ApplyValidatorWeightDiffs iterates from [startHeight] towards the genesis
@@ -330,10 +330,10 @@ type state struct {
 	utxoDB        database.Database
 	utxoState     avax.UTXOState
 
-	cachedSubnets []*txs.Tx // nil if the subnets haven't been loaded
-	addedSubnets  []*txs.Tx
-	subnetBaseDB  database.Database
-	subnetDB      linkeddb.LinkedDB
+	cachedSubnetIDs []ids.ID // nil if the subnets haven't been loaded
+	addedSubnetIDs  []ids.ID
+	subnetBaseDB    database.Database
+	subnetDB        linkeddb.LinkedDB
 
 	// Subnet ID --> Owner of the subnet
 	subnetOwners     map[ids.ID]fx.Owner
@@ -728,39 +728,39 @@ func (s *state) doneInit() error {
 	return s.singletonDB.Put(InitializedKey, nil)
 }
 
-func (s *state) GetSubnets() ([]*txs.Tx, error) {
-	if s.cachedSubnets != nil {
-		return s.cachedSubnets, nil
+func (s *state) GetSubnetIDs() ([]ids.ID, error) {
+	if s.cachedSubnetIDs != nil {
+		return s.cachedSubnetIDs, nil
 	}
 
 	subnetDBIt := s.subnetDB.NewIterator()
 	defer subnetDBIt.Release()
 
-	txs := []*txs.Tx(nil)
+	subnetIDs := []ids.ID{}
 	for subnetDBIt.Next() {
 		subnetIDBytes := subnetDBIt.Key()
 		subnetID, err := ids.ToID(subnetIDBytes)
 		if err != nil {
 			return nil, err
 		}
-		subnetTx, _, err := s.GetTx(subnetID)
-		if err != nil {
-			return nil, err
-		}
-		txs = append(txs, subnetTx)
+		subnetIDs = append(subnetIDs, subnetID)
 	}
 	if err := subnetDBIt.Error(); err != nil {
 		return nil, err
 	}
-	txs = append(txs, s.addedSubnets...)
-	s.cachedSubnets = txs
-	return txs, nil
+	for _, addedSubnetID := range s.addedSubnetIDs {
+		subnetIDs = append(subnetIDs, addedSubnetID)
+	}
+	s.cachedSubnetIDs = subnetIDs
+	return subnetIDs, nil
 }
 
 func (s *state) AddSubnet(createSubnetTx *txs.Tx) {
-	s.addedSubnets = append(s.addedSubnets, createSubnetTx)
-	if s.cachedSubnets != nil {
-		s.cachedSubnets = append(s.cachedSubnets, createSubnetTx)
+	createSubnetTxID := createSubnetTx.ID()
+
+	s.addedSubnetIDs = append(s.addedSubnetIDs, createSubnetTxID)
+	if s.cachedSubnetIDs != nil {
+		s.cachedSubnetIDs = append(s.cachedSubnetIDs, createSubnetTxID)
 	}
 }
 
@@ -2185,14 +2185,12 @@ func (s *state) writeUTXOs() error {
 }
 
 func (s *state) writeSubnets() error {
-	for _, subnet := range s.addedSubnets {
-		subnetID := subnet.ID()
-
+	for _, subnetID := range s.addedSubnetIDs {
 		if err := s.subnetDB.Put(subnetID[:], nil); err != nil {
 			return fmt.Errorf("failed to write subnet: %w", err)
 		}
 	}
-	s.addedSubnets = nil
+	s.addedSubnetIDs = nil
 	return nil
 }
 
diff --git a/vms/platformvm/vm.go b/vms/platformvm/vm.go
index f33451b18d48..b6417bbd0c45 100644
--- a/vms/platformvm/vm.go
+++ b/vms/platformvm/vm.go
@@ -302,12 +302,12 @@ func (vm *VM) initBlockchains() error {
 			}
 		}
 	} else {
-		subnets, err := vm.state.GetSubnets()
+		subnetIDs, err := vm.state.GetSubnetIDs()
 		if err != nil {
 			return err
 		}
-		for _, subnet := range subnets {
-			if err := vm.createSubnet(subnet.ID()); err != nil {
+		for _, subnetID := range subnetIDs {
+			if err := vm.createSubnet(subnetID); err != nil {
 				return err
 			}
 		}
diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go
index 13802ad4dae2..9fc376f8f180 100644
--- a/vms/platformvm/vm_test.go
+++ b/vms/platformvm/vm_test.go
@@ -958,12 +958,12 @@ func TestCreateSubnet(t *testing.T) {
 	require.NoError(err)
 	require.Equal(status.Committed, txStatus)
 
-	subnets, err := vm.state.GetSubnets()
+	subnetIDs, err := vm.state.GetSubnetIDs()
 	require.NoError(err)
 
 	found := false
-	for _, subnet := range subnets {
-		if subnet.ID() == createSubnetTx.ID() {
+	for _, subnetID := range subnetIDs {
+		if subnetID == createSubnetTx.ID() {
 			found = true
 			break
 		}

From fdb5b96feffb32f340c5fec9721f69fc8cd9e7db Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Tue, 28 May 2024 12:28:45 -0400
Subject: [PATCH 3/7] lint

---
 vms/platformvm/state/state.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go
index 41244ef3df1e..6dd2f92a4bc3 100644
--- a/vms/platformvm/state/state.go
+++ b/vms/platformvm/state/state.go
@@ -748,9 +748,7 @@ func (s *state) GetSubnetIDs() ([]ids.ID, error) {
 	if err := subnetDBIt.Error(); err != nil {
 		return nil, err
 	}
-	for _, addedSubnetID := range s.addedSubnetIDs {
-		subnetIDs = append(subnetIDs, addedSubnetID)
-	}
+	subnetIDs = append(subnetIDs, s.addedSubnetIDs...)
 	s.cachedSubnetIDs = subnetIDs
 	return subnetIDs, nil
 }

From fb7eddfbd475b4ebcbe8eb402a9cd9710ad2454c Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Wed, 29 May 2024 18:57:32 -0400
Subject: [PATCH 4/7] nits

---
 vms/platformvm/state/diff.go      | 10 +++++-----
 vms/platformvm/state/diff_test.go |  8 ++++----
 vms/platformvm/state/state.go     |  6 ++----
 vms/platformvm/vm_test.go         | 23 ++++++++---------------
 4 files changed, 19 insertions(+), 28 deletions(-)

diff --git a/vms/platformvm/state/diff.go b/vms/platformvm/state/diff.go
index 907c3c56ef7d..6290f07188ff 100644
--- a/vms/platformvm/state/diff.go
+++ b/vms/platformvm/state/diff.go
@@ -43,7 +43,7 @@ type diff struct {
 	modifiedDelegateeRewards map[ids.ID]map[ids.NodeID]uint64
 	pendingStakerDiffs       diffStakers
 
-	addedSubnets []*txs.Tx
+	addedSubnetIDs []ids.ID
 	// Subnet ID --> Owner of the subnet
 	subnetOwners map[ids.ID]fx.Owner
 	// Subnet ID --> Tx that transforms the subnet
@@ -272,8 +272,8 @@ func (d *diff) GetPendingStakerIterator() (StakerIterator, error) {
 	return d.pendingStakerDiffs.GetStakerIterator(parentIterator), nil
 }
 
-func (d *diff) AddSubnet(createSubnetTx *txs.Tx) {
-	d.addedSubnets = append(d.addedSubnets, createSubnetTx)
+func (d *diff) AddSubnet(createSubnetTxID ids.ID) {
+	d.addedSubnetIDs = append(d.addedSubnetIDs, createSubnetTxID)
 }
 
 func (d *diff) GetSubnetOwner(subnetID ids.ID) (fx.Owner, error) {
@@ -451,8 +451,8 @@ func (d *diff) Apply(baseState Chain) error {
 			}
 		}
 	}
-	for _, subnet := range d.addedSubnets {
-		baseState.AddSubnet(subnet)
+	for _, subnetID := range d.addedSubnetIDs {
+		baseState.AddSubnet(subnetID)
 	}
 	for _, tx := range d.transformedSubnets {
 		baseState.AddSubnetTransformation(tx)
diff --git a/vms/platformvm/state/diff_test.go b/vms/platformvm/state/diff_test.go
index 0f65b0936113..9b8fe1e6486b 100644
--- a/vms/platformvm/state/diff_test.go
+++ b/vms/platformvm/state/diff_test.go
@@ -257,7 +257,7 @@ func TestDiffSubnet(t *testing.T) {
 			Owner: fx.NewMockOwner(ctrl),
 		},
 	}
-	state.AddSubnet(parentStateCreateSubnetTx)
+	state.AddSubnet(parentStateCreateSubnetTx.ID())
 
 	// Verify parent returns one subnet
 	subnetIDs, err := state.GetSubnetIDs()
@@ -279,7 +279,7 @@ func TestDiffSubnet(t *testing.T) {
 			Owner: fx.NewMockOwner(ctrl),
 		},
 	}
-	diff.AddSubnet(createSubnetTx)
+	diff.AddSubnet(createSubnetTx.ID())
 
 	// Apply diff to parent state
 	require.NoError(diff.Apply(state))
@@ -547,7 +547,7 @@ func TestDiffSubnetOwner(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(owner)
 
-	state.AddSubnet(createSubnetTx)
+	state.AddSubnet(subnetID)
 	state.SetSubnetOwner(subnetID, owner1)
 
 	owner, err = state.GetSubnetOwner(subnetID)
@@ -610,7 +610,7 @@ func TestDiffStacking(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(owner)
 
-	state.AddSubnet(createSubnetTx)
+	state.AddSubnet(subnetID)
 	state.SetSubnetOwner(subnetID, owner1)
 
 	owner, err = state.GetSubnetOwner(subnetID)
diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go
index 6dd2f92a4bc3..53d7486f70cd 100644
--- a/vms/platformvm/state/state.go
+++ b/vms/platformvm/state/state.go
@@ -104,7 +104,7 @@ type Chain interface {
 
 	AddRewardUTXO(txID ids.ID, utxo *avax.UTXO)
 
-	AddSubnet(createSubnetTx *txs.Tx)
+	AddSubnet(createSubnetTxID ids.ID)
 
 	GetSubnetOwner(subnetID ids.ID) (fx.Owner, error)
 	SetSubnetOwner(subnetID ids.ID, owner fx.Owner)
@@ -753,9 +753,7 @@ func (s *state) GetSubnetIDs() ([]ids.ID, error) {
 	return subnetIDs, nil
 }
 
-func (s *state) AddSubnet(createSubnetTx *txs.Tx) {
-	createSubnetTxID := createSubnetTx.ID()
-
+func (s *state) AddSubnet(createSubnetTxID ids.ID) {
 	s.addedSubnetIDs = append(s.addedSubnetIDs, createSubnetTxID)
 	if s.cachedSubnetIDs != nil {
 		s.cachedSubnetIDs = append(s.cachedSubnetIDs, createSubnetTxID)
diff --git a/vms/platformvm/vm_test.go b/vms/platformvm/vm_test.go
index 9fc376f8f180..dbd766b2a6e1 100644
--- a/vms/platformvm/vm_test.go
+++ b/vms/platformvm/vm_test.go
@@ -941,6 +941,7 @@ func TestCreateSubnet(t *testing.T) {
 		}),
 	)
 	require.NoError(err)
+	subnetID := createSubnetTx.ID()
 
 	vm.ctx.Lock.Unlock()
 	require.NoError(vm.issueTxFromRPC(createSubnetTx))
@@ -954,21 +955,13 @@ func TestCreateSubnet(t *testing.T) {
 	require.NoError(blk.Accept(context.Background()))
 	require.NoError(vm.SetPreference(context.Background(), vm.manager.LastAccepted()))
 
-	_, txStatus, err := vm.state.GetTx(createSubnetTx.ID())
+	_, txStatus, err := vm.state.GetTx(subnetID)
 	require.NoError(err)
 	require.Equal(status.Committed, txStatus)
 
 	subnetIDs, err := vm.state.GetSubnetIDs()
 	require.NoError(err)
-
-	found := false
-	for _, subnetID := range subnetIDs {
-		if subnetID == createSubnetTx.ID() {
-			found = true
-			break
-		}
-	}
-	require.True(found)
+	require.Contains(subnetIDs, subnetID)
 
 	// Now that we've created a new subnet, add a validator to that subnet
 	startTime := vm.clock.Time().Add(txexecutor.SyncBound).Add(1 * time.Second)
@@ -982,7 +975,7 @@ func TestCreateSubnet(t *testing.T) {
 				End:    uint64(endTime.Unix()),
 				Wght:   defaultWeight,
 			},
-			Subnet: createSubnetTx.ID(),
+			Subnet: subnetID,
 		},
 		[]*secp256k1.PrivateKey{keys[0]},
 	)
@@ -1004,10 +997,10 @@ func TestCreateSubnet(t *testing.T) {
 	require.NoError(err)
 	require.Equal(status.Committed, txStatus)
 
-	_, err = vm.state.GetPendingValidator(createSubnetTx.ID(), nodeID)
+	_, err = vm.state.GetPendingValidator(subnetID, nodeID)
 	require.ErrorIs(err, database.ErrNotFound)
 
-	_, err = vm.state.GetCurrentValidator(createSubnetTx.ID(), nodeID)
+	_, err = vm.state.GetCurrentValidator(subnetID, nodeID)
 	require.NoError(err)
 
 	// fast forward clock to time validator should stop validating
@@ -1017,10 +1010,10 @@ func TestCreateSubnet(t *testing.T) {
 	require.NoError(blk.Verify(context.Background()))
 	require.NoError(blk.Accept(context.Background())) // remove validator from current validator set
 
-	_, err = vm.state.GetPendingValidator(createSubnetTx.ID(), nodeID)
+	_, err = vm.state.GetPendingValidator(subnetID, nodeID)
 	require.ErrorIs(err, database.ErrNotFound)
 
-	_, err = vm.state.GetCurrentValidator(createSubnetTx.ID(), nodeID)
+	_, err = vm.state.GetCurrentValidator(subnetID, nodeID)
 	require.ErrorIs(err, database.ErrNotFound)
 }
 

From fea3ad58d05a1f3c88ae623882151e7f806b27ef Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Wed, 29 May 2024 18:57:55 -0400
Subject: [PATCH 5/7] nit

---
 vms/platformvm/state/mock_state.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/vms/platformvm/state/mock_state.go b/vms/platformvm/state/mock_state.go
index 38203c5a5b43..c1321567e6a9 100644
--- a/vms/platformvm/state/mock_state.go
+++ b/vms/platformvm/state/mock_state.go
@@ -75,7 +75,7 @@ func (mr *MockChainMockRecorder) AddRewardUTXO(arg0, arg1 any) *gomock.Call {
 }
 
 // AddSubnet mocks base method.
-func (m *MockChain) AddSubnet(arg0 *txs.Tx) {
+func (m *MockChain) AddSubnet(arg0 ids.ID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddSubnet", arg0)
 }
@@ -523,7 +523,7 @@ func (mr *MockDiffMockRecorder) AddRewardUTXO(arg0, arg1 any) *gomock.Call {
 }
 
 // AddSubnet mocks base method.
-func (m *MockDiff) AddSubnet(arg0 *txs.Tx) {
+func (m *MockDiff) AddSubnet(arg0 ids.ID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddSubnet", arg0)
 }
@@ -1009,7 +1009,7 @@ func (mr *MockStateMockRecorder) AddStatelessBlock(arg0 any) *gomock.Call {
 }
 
 // AddSubnet mocks base method.
-func (m *MockState) AddSubnet(arg0 *txs.Tx) {
+func (m *MockState) AddSubnet(arg0 ids.ID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddSubnet", arg0)
 }

From ceef49f03260afc22151cae882f74932bc514744 Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Wed, 29 May 2024 19:01:00 -0400
Subject: [PATCH 6/7] nit

---
 vms/platformvm/state/state_test.go                  | 2 +-
 vms/platformvm/txs/executor/standard_tx_executor.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/vms/platformvm/state/state_test.go b/vms/platformvm/state/state_test.go
index abfd1f34feee..c6241ddc8cc4 100644
--- a/vms/platformvm/state/state_test.go
+++ b/vms/platformvm/state/state_test.go
@@ -1388,7 +1388,7 @@ func TestStateSubnetOwner(t *testing.T) {
 	require.ErrorIs(err, database.ErrNotFound)
 	require.Nil(owner)
 
-	state.AddSubnet(createSubnetTx)
+	state.AddSubnet(subnetID)
 	state.SetSubnetOwner(subnetID, owner1)
 
 	owner, err = state.GetSubnetOwner(subnetID)
diff --git a/vms/platformvm/txs/executor/standard_tx_executor.go b/vms/platformvm/txs/executor/standard_tx_executor.go
index 725f1aaff814..2de7d3392ba8 100644
--- a/vms/platformvm/txs/executor/standard_tx_executor.go
+++ b/vms/platformvm/txs/executor/standard_tx_executor.go
@@ -140,7 +140,7 @@ func (e *StandardTxExecutor) CreateSubnetTx(tx *txs.CreateSubnetTx) error {
 	// Produce the UTXOS
 	avax.Produce(e.State, txID, tx.Outs)
 	// Add the new subnet to the database
-	e.State.AddSubnet(e.Tx)
+	e.State.AddSubnet(txID)
 	e.State.SetSubnetOwner(txID, tx.Owner)
 	return nil
 }

From 988de1b20818a150050f08d95a80560d233856c9 Mon Sep 17 00:00:00 2001
From: dhrubabasu <7675102+dhrubabasu@users.noreply.github.com>
Date: Wed, 29 May 2024 19:02:26 -0400
Subject: [PATCH 7/7] nit

---
 vms/platformvm/state/diff.go  | 4 ++--
 vms/platformvm/state/state.go | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/vms/platformvm/state/diff.go b/vms/platformvm/state/diff.go
index 6290f07188ff..91fb01d08fc9 100644
--- a/vms/platformvm/state/diff.go
+++ b/vms/platformvm/state/diff.go
@@ -272,8 +272,8 @@ func (d *diff) GetPendingStakerIterator() (StakerIterator, error) {
 	return d.pendingStakerDiffs.GetStakerIterator(parentIterator), nil
 }
 
-func (d *diff) AddSubnet(createSubnetTxID ids.ID) {
-	d.addedSubnetIDs = append(d.addedSubnetIDs, createSubnetTxID)
+func (d *diff) AddSubnet(subnetID ids.ID) {
+	d.addedSubnetIDs = append(d.addedSubnetIDs, subnetID)
 }
 
 func (d *diff) GetSubnetOwner(subnetID ids.ID) (fx.Owner, error) {
diff --git a/vms/platformvm/state/state.go b/vms/platformvm/state/state.go
index 53d7486f70cd..295e67c52ff3 100644
--- a/vms/platformvm/state/state.go
+++ b/vms/platformvm/state/state.go
@@ -104,7 +104,7 @@ type Chain interface {
 
 	AddRewardUTXO(txID ids.ID, utxo *avax.UTXO)
 
-	AddSubnet(createSubnetTxID ids.ID)
+	AddSubnet(subnetID ids.ID)
 
 	GetSubnetOwner(subnetID ids.ID) (fx.Owner, error)
 	SetSubnetOwner(subnetID ids.ID, owner fx.Owner)
@@ -753,10 +753,10 @@ func (s *state) GetSubnetIDs() ([]ids.ID, error) {
 	return subnetIDs, nil
 }
 
-func (s *state) AddSubnet(createSubnetTxID ids.ID) {
-	s.addedSubnetIDs = append(s.addedSubnetIDs, createSubnetTxID)
+func (s *state) AddSubnet(subnetID ids.ID) {
+	s.addedSubnetIDs = append(s.addedSubnetIDs, subnetID)
 	if s.cachedSubnetIDs != nil {
-		s.cachedSubnetIDs = append(s.cachedSubnetIDs, createSubnetTxID)
+		s.cachedSubnetIDs = append(s.cachedSubnetIDs, subnetID)
 	}
 }