github.com/ava-labs/avalanchego@v1.11.11/vms/components/avax/utxo_fetching_test.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package avax
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/require"
    10  
    11  	"github.com/ava-labs/avalanchego/codec"
    12  	"github.com/ava-labs/avalanchego/codec/linearcodec"
    13  	"github.com/ava-labs/avalanchego/database/memdb"
    14  	"github.com/ava-labs/avalanchego/ids"
    15  	"github.com/ava-labs/avalanchego/utils/set"
    16  	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
    17  )
    18  
    19  func TestFetchUTXOs(t *testing.T) {
    20  	require := require.New(t)
    21  
    22  	txID := ids.GenerateTestID()
    23  	assetID := ids.GenerateTestID()
    24  	addr := ids.GenerateTestShortID()
    25  	addrs := set.Of(addr)
    26  	utxo := &UTXO{
    27  		UTXOID: UTXOID{
    28  			TxID:        txID,
    29  			OutputIndex: 0,
    30  		},
    31  		Asset: Asset{ID: assetID},
    32  		Out: &secp256k1fx.TransferOutput{
    33  			Amt: 12345,
    34  			OutputOwners: secp256k1fx.OutputOwners{
    35  				Locktime:  54321,
    36  				Threshold: 1,
    37  				Addrs:     []ids.ShortID{addr},
    38  			},
    39  		},
    40  	}
    41  
    42  	c := linearcodec.NewDefault()
    43  	manager := codec.NewDefaultManager()
    44  
    45  	require.NoError(c.RegisterType(&secp256k1fx.TransferOutput{}))
    46  	require.NoError(manager.RegisterCodec(codecVersion, c))
    47  
    48  	db := memdb.New()
    49  	s, err := NewUTXOState(db, manager, trackChecksum)
    50  	require.NoError(err)
    51  
    52  	require.NoError(s.PutUTXO(utxo))
    53  
    54  	utxos, err := GetAllUTXOs(s, addrs)
    55  	require.NoError(err)
    56  	require.Len(utxos, 1)
    57  	require.Equal(utxo, utxos[0])
    58  
    59  	balance, err := GetBalance(s, addrs)
    60  	require.NoError(err)
    61  	require.Equal(uint64(12345), balance)
    62  }
    63  
    64  // TestGetPaginatedUTXOs tests
    65  // - Pagination when the total UTXOs exceed maxUTXOsToFetch (512)
    66  // - Fetching all UTXOs when they exceed maxUTXOsToFetch (512)
    67  func TestGetPaginatedUTXOs(t *testing.T) {
    68  	require := require.New(t)
    69  
    70  	addr0 := ids.GenerateTestShortID()
    71  	addr1 := ids.GenerateTestShortID()
    72  	addr2 := ids.GenerateTestShortID()
    73  	addrs := set.Of(addr0, addr1)
    74  
    75  	c := linearcodec.NewDefault()
    76  	manager := codec.NewDefaultManager()
    77  
    78  	require.NoError(c.RegisterType(&secp256k1fx.TransferOutput{}))
    79  	require.NoError(manager.RegisterCodec(codecVersion, c))
    80  
    81  	db := memdb.New()
    82  	s, err := NewUTXOState(db, manager, trackChecksum)
    83  	require.NoError(err)
    84  
    85  	// Create 1000 UTXOs each on addr0, addr1, and addr2.
    86  	for i := 0; i < 1000; i++ {
    87  		txID := ids.GenerateTestID()
    88  		assetID := ids.GenerateTestID()
    89  		utxo0 := &UTXO{
    90  			UTXOID: UTXOID{
    91  				TxID:        txID,
    92  				OutputIndex: 0,
    93  			},
    94  			Asset: Asset{ID: assetID},
    95  			Out: &secp256k1fx.TransferOutput{
    96  				Amt: 12345,
    97  				OutputOwners: secp256k1fx.OutputOwners{
    98  					Locktime:  54321,
    99  					Threshold: 1,
   100  					Addrs:     []ids.ShortID{addr0},
   101  				},
   102  			},
   103  		}
   104  		require.NoError(s.PutUTXO(utxo0))
   105  
   106  		utxo1 := &UTXO{
   107  			UTXOID: UTXOID{
   108  				TxID:        txID,
   109  				OutputIndex: 1,
   110  			},
   111  			Asset: Asset{ID: assetID},
   112  			Out: &secp256k1fx.TransferOutput{
   113  				Amt: 12345,
   114  				OutputOwners: secp256k1fx.OutputOwners{
   115  					Locktime:  54321,
   116  					Threshold: 1,
   117  					Addrs:     []ids.ShortID{addr1},
   118  				},
   119  			},
   120  		}
   121  		require.NoError(s.PutUTXO(utxo1))
   122  
   123  		utxo2 := &UTXO{
   124  			UTXOID: UTXOID{
   125  				TxID:        txID,
   126  				OutputIndex: 2,
   127  			},
   128  			Asset: Asset{ID: assetID},
   129  			Out: &secp256k1fx.TransferOutput{
   130  				Amt: 12345,
   131  				OutputOwners: secp256k1fx.OutputOwners{
   132  					Locktime:  54321,
   133  					Threshold: 1,
   134  					Addrs:     []ids.ShortID{addr2},
   135  				},
   136  			},
   137  		}
   138  		require.NoError(s.PutUTXO(utxo2))
   139  	}
   140  
   141  	var (
   142  		fetchedUTXOs []*UTXO
   143  		lastAddr     = ids.ShortEmpty
   144  		lastIdx      = ids.Empty
   145  		totalUTXOs   []*UTXO
   146  	)
   147  	for i := 0; i <= 10; i++ {
   148  		fetchedUTXOs, lastAddr, lastIdx, err = GetPaginatedUTXOs(s, addrs, lastAddr, lastIdx, 512)
   149  		require.NoError(err)
   150  
   151  		totalUTXOs = append(totalUTXOs, fetchedUTXOs...)
   152  	}
   153  
   154  	require.Len(totalUTXOs, 2000)
   155  
   156  	// Fetch all UTXOs
   157  	notPaginatedUTXOs, err := GetAllUTXOs(s, addrs)
   158  	require.NoError(err)
   159  	require.Len(notPaginatedUTXOs, len(totalUTXOs))
   160  }