Deep VM Queries (for older epochs, as well)

factory/api/apiResolverFactory.go

@@ -322,7 +322,7 @@
 	list := make([]process.SCQueryService, 0, numConcurrentVms)
 	for i := 0; i < numConcurrentVms; i++ {
 		argsQueryElem.index = i
-		scQueryService, err = createScQueryElement(argsQueryElem)
+		scQueryService, err = createScQueryElement(*argsQueryElem)
 		if err != nil {
 			return nil, err
 		}
@@ -339,7 +339,7 @@
 }
 
 func createScQueryElement(
-	args *scQueryElementArgs,
+	args scQueryElementArgs,
 ) (process.SCQueryService, error) {
 	var err error
 
@@ -356,10 +356,20 @@
 		return nil, errDecode
 	}
 
+	apiBlockchain, err := blockchain.NewBlockChain(disabled.NewAppStatusHandler())
+	if err != nil {
+		return nil, err
+	}
+
+	accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain)
+	if err != nil {
+		return nil, err
+	}
+
 	builtInFuncFactory, err := createBuiltinFuncs(
 		args.gasScheduleNotifier,
 		args.coreComponents.InternalMarshalizer(),
-		args.stateComponents.AccountsAdapterAPI(),
+		accountsAdapterApi,
 		args.processComponents.ShardCoordinator(),
 		args.coreComponents.EpochNotifier(),
 		args.coreComponents.EnableEpochsHandler(),
@@ -399,16 +409,17 @@
 		GasSchedule:              args.gasScheduleNotifier,
 		Counter:                  counters.NewDisabledCounter(),
 		MissingTrieNodesNotifier: syncer.NewMissingTrieNodesNotifier(),
+		Accounts:                 accountsAdapterApi,
+		BlockChain:               apiBlockchain,
 	}
 
-	var apiBlockchain data.ChainHandler
 	var vmFactory process.VirtualMachinesContainerFactory
 	maxGasForVmQueries := args.generalConfig.VirtualMachine.GasConfig.ShardMaxGasPerVmQuery
 	if args.processComponents.ShardCoordinator().SelfId() == core.MetachainShardId {
 		maxGasForVmQueries = args.generalConfig.VirtualMachine.GasConfig.MetaMaxGasPerVmQuery
-		apiBlockchain, vmFactory, err = createMetaVmContainerFactory(args, argsHook)
+		vmFactory, err = createMetaVmContainerFactory(args, argsHook)
 	} else {
-		apiBlockchain, vmFactory, err = createShardVmContainerFactory(args, argsHook)
+		vmFactory, err = createShardVmContainerFactory(args, argsHook)
 	}
 	if err != nil {
 		return nil, err
@@ -452,23 +463,10 @@
 	return smartContract.NewSCQueryService(argsNewSCQueryService)
 }
 
-func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (data.ChainHandler, process.VirtualMachinesContainerFactory, error) {
-	apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler())
-	if err != nil {
-		return nil, nil, err
-	}
-
-	accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	argsHook.BlockChain = apiBlockchain
-	argsHook.Accounts = accountsAdapterApi
-
+func createMetaVmContainerFactory(args scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (process.VirtualMachinesContainerFactory, error) {
 	blockChainHookImpl, errBlockChainHook := hooks.NewBlockChainHookImpl(argsHook)
 	if errBlockChainHook != nil {
-		return nil, nil, errBlockChainHook
+		return nil, errBlockChainHook
 	}
 
 	argsNewVmFactory := metachain.ArgsNewVMContainerFactory{
@@ -489,35 +487,22 @@
 	}
 	vmFactory, err := metachain.NewVMContainerFactory(argsNewVmFactory)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	return apiBlockchain, vmFactory, nil
+	return vmFactory, nil
 }
 
-func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (data.ChainHandler, process.VirtualMachinesContainerFactory, error) {
-	apiBlockchain, err := blockchain.NewBlockChain(disabled.NewAppStatusHandler())
-	if err != nil {
-		return nil, nil, err
-	}
-
-	accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	argsHook.BlockChain = apiBlockchain
-	argsHook.Accounts = accountsAdapterApi
-
+func createShardVmContainerFactory(args scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (process.VirtualMachinesContainerFactory, error) {
 	queryVirtualMachineConfig := args.generalConfig.VirtualMachine.Querying.VirtualMachineConfig
 	esdtTransferParser, errParser := parsers.NewESDTTransferParser(args.coreComponents.InternalMarshalizer())
 	if errParser != nil {
-		return nil, nil, errParser
+		return nil, errParser
 	}
 
 	blockChainHookImpl, errBlockChainHook := hooks.NewBlockChainHookImpl(argsHook)
 	if errBlockChainHook != nil {
-		return nil, nil, errBlockChainHook
+		return nil, errBlockChainHook
 	}
 
 	argsNewVMFactory := shard.ArgVMContainerFactory{
@@ -539,13 +524,13 @@
 
 	vmFactory, err := shard.NewVMContainerFactory(argsNewVMFactory)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	return apiBlockchain, vmFactory, nil
+	return vmFactory, nil
 }
 
-func createNewAccountsAdapterApi(args *scQueryElementArgs, chainHandler data.ChainHandler) (state.AccountsAdapterAPI, error) {
+func createNewAccountsAdapterApi(args scQueryElementArgs, chainHandler data.ChainHandler) (state.AccountsAdapterAPI, error) {
 	argsAccCreator := factoryState.ArgsAccountCreator{
 		Hasher:              args.coreComponents.Hasher(),
 		Marshaller:          args.coreComponents.InternalMarshalizer(),
@@ -622,7 +607,7 @@
 	return state.NewAccountsDBApi(accounts, provider)
 }
 
-func newStoragePruningManager(args *scQueryElementArgs) (state.StoragePruningManager, error) {
+func newStoragePruningManager(args scQueryElementArgs) (state.StoragePruningManager, error) {
 	argsMemEviction := evictionWaitingList.MemoryEvictionWaitingListArgs{
 		RootHashesSize: args.generalConfig.EvictionWaitingList.RootHashesSize,
 		HashesSize:     args.generalConfig.EvictionWaitingList.HashesSize,

factory/api/export_test.go

@@ -29,7 +29,7 @@ type SCQueryElementArgs struct {
 
 // CreateScQueryElement -
 func CreateScQueryElement(args SCQueryElementArgs) (process.SCQueryService, error) {
-	return createScQueryElement(&scQueryElementArgs{
+	return createScQueryElement(scQueryElementArgs{
 		generalConfig:         args.GeneralConfig,
 		epochConfig:           args.EpochConfig,
 		coreComponents:        args.CoreComponents,

integrationTests/oneNodeNetwork.go

@@ -9,16 +9,17 @@ import (
 	"github.com/multiversx/mx-chain-go/process"
 )
 
-type oneNodeNetwork struct {
+// OneNodeNetwork is a one-node network, useful for some integration tests
+type OneNodeNetwork struct {
 	Round uint64
 	Nonce uint64
 
 	Node *TestProcessorNode
 }
 
-// NewOneNodeNetwork creates a one-node network, useful for some integration tests
-func NewOneNodeNetwork() *oneNodeNetwork {
-	n := &oneNodeNetwork{}
+// NewOneNodeNetwork creates a OneNodeNetwork
+func NewOneNodeNetwork() *OneNodeNetwork {
+	n := &OneNodeNetwork{}
 
 	nodes := CreateNodes(
 		1,
@@ -31,38 +32,38 @@ func NewOneNodeNetwork() *oneNodeNetwork {
 }
 
 // Stop stops the test network
-func (n *oneNodeNetwork) Stop() {
+func (n *OneNodeNetwork) Stop() {
 	n.Node.Close()
 }
 
 // Mint mints the given address
-func (n *oneNodeNetwork) Mint(address []byte, value *big.Int) {
+func (n *OneNodeNetwork) Mint(address []byte, value *big.Int) {
 	MintAddress(n.Node.AccntState, address, value)
 }
 
 // GetMinGasPrice returns the min gas price
-func (n *oneNodeNetwork) GetMinGasPrice() uint64 {
+func (n *OneNodeNetwork) GetMinGasPrice() uint64 {
 	return n.Node.EconomicsData.GetMinGasPrice()
 }
 
 // MaxGasLimitPerBlock returns the max gas per block
-func (n *oneNodeNetwork) MaxGasLimitPerBlock() uint64 {
+func (n *OneNodeNetwork) MaxGasLimitPerBlock() uint64 {
 	return n.Node.EconomicsData.MaxGasLimitPerBlock(0) - 1
 }
 
 // GoToRoundOne advances processing to block and round 1
-func (n *oneNodeNetwork) GoToRoundOne() {
+func (n *OneNodeNetwork) GoToRoundOne() {
 	n.Round = IncrementAndPrintRound(n.Round)
 	n.Nonce++
 }
 
 // Continue advances processing with a number of rounds
-func (n *oneNodeNetwork) Continue(t *testing.T, numRounds int) {
+func (n *OneNodeNetwork) Continue(t *testing.T, numRounds int) {
 	n.Nonce, n.Round = WaitOperationToBeDone(t, []*TestProcessorNode{n.Node}, numRounds, n.Nonce, n.Round, []int{0})
 }
 
 // AddTxToPool adds a transaction to the pool (skips signature checks and interceptors)
-func (n *oneNodeNetwork) AddTxToPool(tx *transaction.Transaction) {
+func (n *OneNodeNetwork) AddTxToPool(tx *transaction.Transaction) {
 	txHash, _ := core.CalculateHash(TestMarshalizer, TestHasher, tx)
 	sourceShard := n.Node.ShardCoordinator.ComputeId(tx.SndAddr)
 	cacheIdentifier := process.ShardCacherIdentifier(sourceShard, sourceShard)