Skip to content

Commit 9b85141

Browse files
dhrubabasudhrubabasu
authored
vms/platformvm: Move GetRewardUTXOs, GetSubnets, and GetChains to State interface (#2402)
1 parent de3b16c commit 9b85141

File tree

4 files changed

+88
-270
lines changed

4 files changed

+88
-270
lines changed

‎vms/platformvm/state/diff.go‎

Lines changed: 1 addition & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -47,10 +47,8 @@ type diff struct {
4747
subnetOwners map[ids.ID]fx.Owner
4848
// Subnet ID --> Tx that transforms the subnet
4949
transformedSubnets map[ids.ID]*txs.Tx
50-
cachedSubnets []*txs.Tx
5150

52-
addedChains map[ids.ID][]*txs.Tx
53-
cachedChains map[ids.ID][]*txs.Tx
51+
addedChains map[ids.ID][]*txs.Tx
5452

5553
addedRewardUTXOs map[ids.ID][]*avax.UTXO
5654

@@ -259,41 +257,8 @@ func (d *diff) GetPendingStakerIterator() (StakerIterator, error) {
259257
return d.pendingStakerDiffs.GetStakerIterator(parentIterator), nil
260258
}
261259

262-
func (d *diff) GetSubnets() ([]*txs.Tx, error) {
263-
if len(d.addedSubnets) == 0 {
264-
parentState, ok := d.stateVersions.GetState(d.parentID)
265-
if !ok {
266-
return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
267-
}
268-
return parentState.GetSubnets()
269-
}
270-
271-
if len(d.cachedSubnets) != 0 {
272-
return d.cachedSubnets, nil
273-
}
274-
275-
parentState, ok := d.stateVersions.GetState(d.parentID)
276-
if !ok {
277-
return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
278-
}
279-
subnets, err := parentState.GetSubnets()
280-
if err != nil {
281-
return nil, err
282-
}
283-
newSubnets := make([]*txs.Tx, len(subnets)+len(d.addedSubnets))
284-
copy(newSubnets, subnets)
285-
for i, subnet := range d.addedSubnets {
286-
newSubnets[i+len(subnets)] = subnet
287-
}
288-
d.cachedSubnets = newSubnets
289-
return newSubnets, nil
290-
}
291-
292260
func (d *diff) AddSubnet(createSubnetTx *txs.Tx) {
293261
d.addedSubnets = append(d.addedSubnets, createSubnetTx)
294-
if d.cachedSubnets != nil {
295-
d.cachedSubnets = append(d.cachedSubnets, createSubnetTx)
296-
}
297262
}
298263

299264
func (d *diff) GetSubnetOwner(subnetID ids.ID) (fx.Owner, error) {
@@ -339,48 +304,6 @@ func (d *diff) AddSubnetTransformation(transformSubnetTxIntf *txs.Tx) {
339304
}
340305
}
341306

342-
func (d *diff) GetChains(subnetID ids.ID) ([]*txs.Tx, error) {
343-
addedChains := d.addedChains[subnetID]
344-
if len(addedChains) == 0 {
345-
// No chains have been added to this subnet
346-
parentState, ok := d.stateVersions.GetState(d.parentID)
347-
if !ok {
348-
return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
349-
}
350-
return parentState.GetChains(subnetID)
351-
}
352-
353-
// There have been chains added to the requested subnet
354-
355-
if d.cachedChains == nil {
356-
// This is the first time we are going to be caching the subnet chains
357-
d.cachedChains = make(map[ids.ID][]*txs.Tx)
358-
}
359-
360-
cachedChains, cached := d.cachedChains[subnetID]
361-
if cached {
362-
return cachedChains, nil
363-
}
364-
365-
// This chain wasn't cached yet
366-
parentState, ok := d.stateVersions.GetState(d.parentID)
367-
if !ok {
368-
return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
369-
}
370-
chains, err := parentState.GetChains(subnetID)
371-
if err != nil {
372-
return nil, err
373-
}
374-
375-
newChains := make([]*txs.Tx, len(chains)+len(addedChains))
376-
copy(newChains, chains)
377-
for i, chain := range addedChains {
378-
newChains[i+len(chains)] = chain
379-
}
380-
d.cachedChains[subnetID] = newChains
381-
return newChains, nil
382-
}
383-
384307
func (d *diff) AddChain(createChainTx *txs.Tx) {
385308
tx := createChainTx.Unsigned.(*txs.CreateChainTx)
386309
if d.addedChains == nil {
@@ -390,12 +313,6 @@ func (d *diff) AddChain(createChainTx *txs.Tx) {
390313
} else {
391314
d.addedChains[tx.SubnetID] = append(d.addedChains[tx.SubnetID], createChainTx)
392315
}
393-
394-
cachedChains, cached := d.cachedChains[tx.SubnetID]
395-
if !cached {
396-
return
397-
}
398-
d.cachedChains[tx.SubnetID] = append(cachedChains, createChainTx)
399316
}
400317

401318
func (d *diff) GetTx(txID ids.ID) (*txs.Tx, status.Status, error) {
@@ -425,18 +342,6 @@ func (d *diff) AddTx(tx *txs.Tx, status status.Status) {
425342
}
426343
}
427344

428-
func (d *diff) GetRewardUTXOs(txID ids.ID) ([]*avax.UTXO, error) {
429-
if utxos, exists := d.addedRewardUTXOs[txID]; exists {
430-
return utxos, nil
431-
}
432-
433-
parentState, ok := d.stateVersions.GetState(d.parentID)
434-
if !ok {
435-
return nil, fmt.Errorf("%w: %s", ErrMissingParentState, d.parentID)
436-
}
437-
return parentState.GetRewardUTXOs(txID)
438-
}
439-
440345
func (d *diff) AddRewardUTXO(txID ids.ID, utxo *avax.UTXO) {
441346
if d.addedRewardUTXOs == nil {
442347
d.addedRewardUTXOs = make(map[ids.ID][]*avax.UTXO)

‎vms/platformvm/state/diff_test.go‎

Lines changed: 83 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -250,15 +250,28 @@ func TestDiffSubnet(t *testing.T) {
250250
require := require.New(t)
251251
ctrl := gomock.NewController(t)
252252

253-
state := NewMockState(ctrl)
254-
// Called in NewDiff
255-
state.EXPECT().GetTimestamp().Return(time.Now()).Times(1)
253+
state, _ := newInitializedState(require)
254+
255+
// Initialize parent with one subnet
256+
parentStateCreateSubnetTx := &txs.Tx{
257+
Unsigned: &txs.CreateSubnetTx{
258+
Owner: fx.NewMockOwner(ctrl),
259+
},
260+
}
261+
state.AddSubnet(parentStateCreateSubnetTx)
262+
263+
// Verify parent returns one subnet
264+
subnets, err := state.GetSubnets()
265+
require.NoError(err)
266+
require.Equal([]*txs.Tx{
267+
parentStateCreateSubnetTx,
268+
}, subnets)
256269

257270
states := NewMockVersions(ctrl)
258271
lastAcceptedID := ids.GenerateTestID()
259272
states.EXPECT().GetState(lastAcceptedID).Return(state, true).AnyTimes()
260273

261-
d, err := NewDiff(lastAcceptedID, states)
274+
diff, err := NewDiff(lastAcceptedID, states)
262275
require.NoError(err)
263276

264277
// Put a subnet
@@ -267,60 +280,67 @@ func TestDiffSubnet(t *testing.T) {
267280
Owner: fx.NewMockOwner(ctrl),
268281
},
269282
}
270-
d.AddSubnet(createSubnetTx)
283+
diff.AddSubnet(createSubnetTx)
271284

272-
// Assert that we get the subnet back
273-
// [state] returns 1 subnet.
274-
parentStateCreateSubnetTx := &txs.Tx{
275-
Unsigned: &txs.CreateSubnetTx{
276-
Owner: fx.NewMockOwner(ctrl),
277-
},
278-
}
279-
state.EXPECT().GetSubnets().Return([]*txs.Tx{parentStateCreateSubnetTx}, nil).Times(1)
280-
gotSubnets, err := d.GetSubnets()
285+
// Apply diff to parent state
286+
require.NoError(diff.Apply(state))
287+
288+
// Verify parent now returns two subnets
289+
subnets, err = state.GetSubnets()
281290
require.NoError(err)
282-
require.Len(gotSubnets, 2)
283-
require.Equal(gotSubnets[0], parentStateCreateSubnetTx)
284-
require.Equal(gotSubnets[1], createSubnetTx)
291+
require.Equal([]*txs.Tx{
292+
parentStateCreateSubnetTx,
293+
createSubnetTx,
294+
}, subnets)
285295
}
286296

287297
func TestDiffChain(t *testing.T) {
288298
require := require.New(t)
289299
ctrl := gomock.NewController(t)
290300

291-
state := NewMockState(ctrl)
292-
// Called in NewDiff
293-
state.EXPECT().GetTimestamp().Return(time.Now()).Times(1)
301+
state, _ := newInitializedState(require)
302+
subnetID := ids.GenerateTestID()
303+
304+
// Initialize parent with one chain
305+
parentStateCreateChainTx := &txs.Tx{
306+
Unsigned: &txs.CreateChainTx{
307+
SubnetID: subnetID,
308+
},
309+
}
310+
state.AddChain(parentStateCreateChainTx)
311+
312+
// Verify parent returns one chain
313+
chains, err := state.GetChains(subnetID)
314+
require.NoError(err)
315+
require.Equal([]*txs.Tx{
316+
parentStateCreateChainTx,
317+
}, chains)
294318

295319
states := NewMockVersions(ctrl)
296320
lastAcceptedID := ids.GenerateTestID()
297321
states.EXPECT().GetState(lastAcceptedID).Return(state, true).AnyTimes()
298322

299-
d, err := NewDiff(lastAcceptedID, states)
323+
diff, err := NewDiff(lastAcceptedID, states)
300324
require.NoError(err)
301325

302326
// Put a chain
303-
subnetID := ids.GenerateTestID()
304327
createChainTx := &txs.Tx{
305328
Unsigned: &txs.CreateChainTx{
306-
SubnetID: subnetID,
329+
SubnetID: subnetID, // note this is the same subnet as [parentStateCreateChainTx]
307330
},
308331
}
309-
d.AddChain(createChainTx)
332+
diff.AddChain(createChainTx)
310333

311-
// Assert that we get the chain back
312-
// [state] returns 1 chain.
313-
parentStateCreateChainTx := &txs.Tx{
314-
Unsigned: &txs.CreateChainTx{
315-
SubnetID: subnetID, // note this is the same subnet as [createChainTx]
316-
},
317-
}
318-
state.EXPECT().GetChains(subnetID).Return([]*txs.Tx{parentStateCreateChainTx}, nil).Times(1)
319-
gotChains, err := d.GetChains(subnetID)
334+
// Apply diff to parent state
335+
require.NoError(diff.Apply(state))
336+
337+
// Verify parent now returns two chains
338+
chains, err = state.GetChains(subnetID)
320339
require.NoError(err)
321-
require.Len(gotChains, 2)
322-
require.Equal(parentStateCreateChainTx, gotChains[0])
323-
require.Equal(createChainTx, gotChains[1])
340+
require.Equal([]*txs.Tx{
341+
parentStateCreateChainTx,
342+
createChainTx,
343+
}, chains)
324344
}
325345

326346
func TestDiffTx(t *testing.T) {
@@ -377,45 +397,46 @@ func TestDiffRewardUTXO(t *testing.T) {
377397
require := require.New(t)
378398
ctrl := gomock.NewController(t)
379399

380-
state := NewMockState(ctrl)
381-
// Called in NewDiff
382-
state.EXPECT().GetTimestamp().Return(time.Now()).Times(1)
400+
state, _ := newInitializedState(require)
401+
402+
txID := ids.GenerateTestID()
403+
404+
// Initialize parent with one reward UTXO
405+
parentRewardUTXO := &avax.UTXO{
406+
UTXOID: avax.UTXOID{TxID: txID},
407+
}
408+
state.AddRewardUTXO(txID, parentRewardUTXO)
409+
410+
// Verify parent returns the reward UTXO
411+
rewardUTXOs, err := state.GetRewardUTXOs(txID)
412+
require.NoError(err)
413+
require.Equal([]*avax.UTXO{
414+
parentRewardUTXO,
415+
}, rewardUTXOs)
383416

384417
states := NewMockVersions(ctrl)
385418
lastAcceptedID := ids.GenerateTestID()
386419
states.EXPECT().GetState(lastAcceptedID).Return(state, true).AnyTimes()
387420

388-
d, err := NewDiff(lastAcceptedID, states)
421+
diff, err := NewDiff(lastAcceptedID, states)
389422
require.NoError(err)
390423

391424
// Put a reward UTXO
392-
txID := ids.GenerateTestID()
393425
rewardUTXO := &avax.UTXO{
394426
UTXOID: avax.UTXOID{TxID: txID},
395427
}
396-
d.AddRewardUTXO(txID, rewardUTXO)
428+
diff.AddRewardUTXO(txID, rewardUTXO)
397429

398-
{
399-
// Assert that we get the UTXO back
400-
gotRewardUTXOs, err := d.GetRewardUTXOs(txID)
401-
require.NoError(err)
402-
require.Len(gotRewardUTXOs, 1)
403-
require.Equal(rewardUTXO, gotRewardUTXOs[0])
404-
}
430+
// Apply diff to parent state
431+
require.NoError(diff.Apply(state))
405432

406-
{
407-
// Assert that we can get a UTXO from the parent state
408-
// [state] returns 1 UTXO.
409-
txID2 := ids.GenerateTestID()
410-
parentRewardUTXO := &avax.UTXO{
411-
UTXOID: avax.UTXOID{TxID: txID2},
412-
}
413-
state.EXPECT().GetRewardUTXOs(txID2).Return([]*avax.UTXO{parentRewardUTXO}, nil).Times(1)
414-
gotParentRewardUTXOs, err := d.GetRewardUTXOs(txID2)
415-
require.NoError(err)
416-
require.Len(gotParentRewardUTXOs, 1)
417-
require.Equal(parentRewardUTXO, gotParentRewardUTXOs[0])
418-
}
433+
// Verify parent now returns two reward UTXOs
434+
rewardUTXOs, err = state.GetRewardUTXOs(txID)
435+
require.NoError(err)
436+
require.Equal([]*avax.UTXO{
437+
parentRewardUTXO,
438+
rewardUTXO,
439+
}, rewardUTXOs)
419440
}
420441

421442
func TestDiffUTXO(t *testing.T) {
@@ -496,25 +517,6 @@ func assertChainsEqual(t *testing.T, expected, actual Chain) {
496517
require.NoError(err)
497518

498519
require.Equal(expectedCurrentSupply, actualCurrentSupply)
499-
500-
expectedSubnets, expectedErr := expected.GetSubnets()
501-
actualSubnets, actualErr := actual.GetSubnets()
502-
require.Equal(expectedErr, actualErr)
503-
if expectedErr == nil {
504-
require.Equal(expectedSubnets, actualSubnets)
505-
506-
for _, subnet := range expectedSubnets {
507-
subnetID := subnet.ID()
508-
509-
expectedChains, expectedErr := expected.GetChains(subnetID)
510-
actualChains, actualErr := actual.GetChains(subnetID)
511-
require.Equal(expectedErr, actualErr)
512-
if expectedErr != nil {
513-
continue
514-
}
515-
require.Equal(expectedChains, actualChains)
516-
}
517-
}
518520
}
519521

520522
func TestDiffSubnetOwner(t *testing.T) {

0 commit comments

Comments
 (0)