github.com/ava-labs/avalanchego@v1.11.11/vms/avm/state_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 avm
     5  
     6  import (
     7  	"math"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/ava-labs/avalanchego/ids"
    13  	"github.com/ava-labs/avalanchego/snow/engine/common"
    14  	"github.com/ava-labs/avalanchego/upgrade/upgradetest"
    15  	"github.com/ava-labs/avalanchego/utils/constants"
    16  	"github.com/ava-labs/avalanchego/utils/crypto/secp256k1"
    17  	"github.com/ava-labs/avalanchego/utils/units"
    18  	"github.com/ava-labs/avalanchego/vms/avm/txs"
    19  	"github.com/ava-labs/avalanchego/vms/components/avax"
    20  	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
    21  )
    22  
    23  func TestSetsAndGets(t *testing.T) {
    24  	require := require.New(t)
    25  
    26  	env := setup(t, &envConfig{
    27  		fork: upgradetest.Latest,
    28  		additionalFxs: []*common.Fx{{
    29  			ID: ids.GenerateTestID(),
    30  			Fx: &FxTest{
    31  				InitializeF: func(vmIntf interface{}) error {
    32  					vm := vmIntf.(secp256k1fx.VM)
    33  					return vm.CodecRegistry().RegisterType(&avax.TestState{})
    34  				},
    35  			},
    36  		}},
    37  	})
    38  	defer env.vm.ctx.Lock.Unlock()
    39  
    40  	utxo := &avax.UTXO{
    41  		UTXOID: avax.UTXOID{
    42  			TxID:        ids.Empty,
    43  			OutputIndex: 1,
    44  		},
    45  		Asset: avax.Asset{ID: ids.Empty},
    46  		Out:   &avax.TestState{},
    47  	}
    48  	utxoID := utxo.InputID()
    49  
    50  	tx := &txs.Tx{Unsigned: &txs.BaseTx{BaseTx: avax.BaseTx{
    51  		NetworkID:    constants.UnitTestID,
    52  		BlockchainID: env.vm.ctx.XChainID,
    53  		Ins: []*avax.TransferableInput{{
    54  			UTXOID: avax.UTXOID{
    55  				TxID:        ids.Empty,
    56  				OutputIndex: 0,
    57  			},
    58  			Asset: avax.Asset{ID: assetID},
    59  			In: &secp256k1fx.TransferInput{
    60  				Amt: 20 * units.KiloAvax,
    61  				Input: secp256k1fx.Input{
    62  					SigIndices: []uint32{
    63  						0,
    64  					},
    65  				},
    66  			},
    67  		}},
    68  	}}}
    69  	require.NoError(tx.SignSECP256K1Fx(env.vm.parser.Codec(), [][]*secp256k1.PrivateKey{{keys[0]}}))
    70  
    71  	txID := tx.ID()
    72  
    73  	env.vm.state.AddUTXO(utxo)
    74  	env.vm.state.AddTx(tx)
    75  
    76  	resultUTXO, err := env.vm.state.GetUTXO(utxoID)
    77  	require.NoError(err)
    78  	resultTx, err := env.vm.state.GetTx(txID)
    79  	require.NoError(err)
    80  
    81  	require.Equal(uint32(1), resultUTXO.OutputIndex)
    82  	require.Equal(tx.ID(), resultTx.ID())
    83  }
    84  
    85  func TestFundingNoAddresses(t *testing.T) {
    86  	env := setup(t, &envConfig{
    87  		fork: upgradetest.Latest,
    88  		additionalFxs: []*common.Fx{{
    89  			ID: ids.GenerateTestID(),
    90  			Fx: &FxTest{
    91  				InitializeF: func(vmIntf interface{}) error {
    92  					vm := vmIntf.(secp256k1fx.VM)
    93  					return vm.CodecRegistry().RegisterType(&avax.TestState{})
    94  				},
    95  			},
    96  		}},
    97  	})
    98  	defer env.vm.ctx.Lock.Unlock()
    99  
   100  	utxo := &avax.UTXO{
   101  		UTXOID: avax.UTXOID{
   102  			TxID:        ids.Empty,
   103  			OutputIndex: 1,
   104  		},
   105  		Asset: avax.Asset{ID: ids.Empty},
   106  		Out:   &avax.TestState{},
   107  	}
   108  
   109  	env.vm.state.AddUTXO(utxo)
   110  	env.vm.state.DeleteUTXO(utxo.InputID())
   111  }
   112  
   113  func TestFundingAddresses(t *testing.T) {
   114  	require := require.New(t)
   115  
   116  	env := setup(t, &envConfig{
   117  		fork: upgradetest.Latest,
   118  		additionalFxs: []*common.Fx{{
   119  			ID: ids.GenerateTestID(),
   120  			Fx: &FxTest{
   121  				InitializeF: func(vmIntf interface{}) error {
   122  					vm := vmIntf.(secp256k1fx.VM)
   123  					return vm.CodecRegistry().RegisterType(&avax.TestAddressable{})
   124  				},
   125  			},
   126  		}},
   127  	})
   128  	defer env.vm.ctx.Lock.Unlock()
   129  
   130  	utxo := &avax.UTXO{
   131  		UTXOID: avax.UTXOID{
   132  			TxID:        ids.Empty,
   133  			OutputIndex: 1,
   134  		},
   135  		Asset: avax.Asset{ID: ids.Empty},
   136  		Out: &avax.TestAddressable{
   137  			Addrs: [][]byte{{0}},
   138  		},
   139  	}
   140  
   141  	env.vm.state.AddUTXO(utxo)
   142  	require.NoError(env.vm.state.Commit())
   143  
   144  	utxos, err := env.vm.state.UTXOIDs([]byte{0}, ids.Empty, math.MaxInt32)
   145  	require.NoError(err)
   146  	require.Len(utxos, 1)
   147  	require.Equal(utxo.InputID(), utxos[0])
   148  
   149  	env.vm.state.DeleteUTXO(utxo.InputID())
   150  	require.NoError(env.vm.state.Commit())
   151  
   152  	utxos, err = env.vm.state.UTXOIDs([]byte{0}, ids.Empty, math.MaxInt32)
   153  	require.NoError(err)
   154  	require.Empty(utxos)
   155  }