back transfers improvements

vmhost/contexts/managedType.go

@@ -64,6 +64,7 @@ type managedTypesContext struct {
 type backTransfers struct {
 	ESDTTransfers []*vmcommon.ESDTTransfer
 	CallValue     *big.Int
+	LastIndex     uint32
 }
 
 type managedTypesState struct {
@@ -833,13 +834,20 @@ func (context *managedTypesContext) getKeyValueFromManagedMap(mMapHandle int32,
 }
 
 // AddBackTransfers add transfers to back transfers structure
-func (context *managedTypesContext) AddBackTransfers(transfers []*vmcommon.ESDTTransfer) {
-	context.managedTypesValues.backTransfers.ESDTTransfers = append(context.managedTypesValues.backTransfers.ESDTTransfers, transfers...)
-}
+func (context *managedTypesContext) AddBackTransfers(value *big.Int, transfers []*vmcommon.ESDTTransfer, index uint32) {
+	backTrs := &context.managedTypesValues.backTransfers
+	if context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.FixBackTransferOPCODE) && backTrs.LastIndex >= index {
+		return
+	}
 
-// AddValueOnlyBackTransfer add to back transfer value
-func (context *managedTypesContext) AddValueOnlyBackTransfer(value *big.Int) {
-	context.managedTypesValues.backTransfers.CallValue.Add(context.managedTypesValues.backTransfers.CallValue, value)
+	if backTrs.LastIndex < index {
+		backTrs.LastIndex = index
+	}
+
+	backTrs.CallValue.Add(backTrs.CallValue, value)
+	if len(transfers) > 0 {
+		backTrs.ESDTTransfers = append(backTrs.ESDTTransfers, transfers...)
+	}
 }
 
 // GetBackTransfers returns all ESDT transfers and accumulated value as well, will clean accumulated values
@@ -848,6 +856,7 @@ func (context *managedTypesContext) GetBackTransfers() ([]*vmcommon.ESDTTransfer
 	context.managedTypesValues.backTransfers = backTransfers{
 		ESDTTransfers: make([]*vmcommon.ESDTTransfer, 0),
 		CallValue:     big.NewInt(0),
+		LastIndex:     clonedTransfers.LastIndex,
 	}
 
 	return clonedTransfers.ESDTTransfers, clonedTransfers.CallValue
@@ -857,6 +866,7 @@ func cloneBackTransfers(currentBackTransfers backTransfers) backTransfers {
 	newBackTransfers := backTransfers{
 		ESDTTransfers: make([]*vmcommon.ESDTTransfer, len(currentBackTransfers.ESDTTransfers)),
 		CallValue:     big.NewInt(0).Set(currentBackTransfers.CallValue),
+		LastIndex:     currentBackTransfers.LastIndex,
 	}
 
 	for index, transfer := range currentBackTransfers.ESDTTransfers {

vmhost/flags.go

@@ -14,4 +14,7 @@ const (
 
 	// MaskInternalDependenciesErrorsFlag defines the flag that activates masking of internal dependencies errors
 	MaskInternalDependenciesErrorsFlag core.EnableEpochFlag = "MaskInternalDependenciesErrorsFlag"
+
+	// FixBackTransferOPCODE defines the flag that activates the fix for get back transfer opcode
+	FixBackTransferOPCODE core.EnableEpochFlag = "FixBackTransferOPCODEFlag"
 )

vmhost/hostCore/execution.go

@@ -359,7 +359,7 @@ func (host *vmHost) addNewBackTransfersFromVMOutput(vmOutput *vmcommon.VMOutput,
 
 		if transfer.Value.Cmp(vmhost.Zero) > 0 {
 			if len(transfer.Data) == 0 {
-				host.managedTypesContext.AddValueOnlyBackTransfer(transfer.Value)
+				host.managedTypesContext.AddBackTransfers(transfer.Value, nil, transfer.Index)
 			}
 			continue
 		}
@@ -369,7 +369,7 @@ func (host *vmHost) addNewBackTransfersFromVMOutput(vmOutput *vmcommon.VMOutput,
 			continue
 		}
 
-		host.managedTypesContext.AddBackTransfers(esdtTransfers.ESDTTransfers)
+		host.managedTypesContext.AddBackTransfers(vmhost.Zero, esdtTransfers.ESDTTransfers, transfer.Index)
 	}
 }
 

vmhost/hosttest/managedei_test.go

@@ -1689,6 +1689,185 @@ func Test_Direct_ManagedGetBackTransfers(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func Test_MultipleCalls_ManagedGetBackTransfers(t *testing.T) {
+	testConfig := makeTestConfig()
+	egldBalance := big.NewInt(10)
+	egldTransfer := big.NewInt(1)
+	initialESDTTokenBalance := uint64(100)
+	testConfig.ESDTTokensToTransfer = 5
+	callsNumber := 2
+
+	_, err := test.BuildMockInstanceCallTest(t).
+		WithContracts(
+			test.CreateMockContract(test.ParentAddress).
+				WithBalance(testConfig.ParentBalance).
+				WithConfig(testConfig).
+				WithMethods(func(parentInstance *mock.InstanceMock, config interface{}) {
+					parentInstance.AddMockMethod("callChild", func() *mock.InstanceMock {
+						host := parentInstance.Host
+
+						for i := 0; i < callsNumber; i++ {
+							input := test.DefaultTestContractCallInput()
+							input.GasProvided = testConfig.GasProvidedToChild
+							input.CallerAddr = test.ParentAddress
+							input.RecipientAddr = test.ChildAddress
+							input.Function = "childFunction"
+							returnValue := contracts.ExecuteOnDestContextInMockContracts(host, input)
+							assert.Equal(t, int32(0), returnValue)
+						}
+
+						managedTypes := host.ManagedTypes()
+						esdtTransfers, egld := managedTypes.GetBackTransfers()
+						assert.Equal(t, callsNumber, len(esdtTransfers))
+						for i := 0; i < callsNumber; i++ {
+							assert.Equal(t, test.ESDTTestTokenName, esdtTransfers[i].ESDTTokenName)
+							assert.Equal(t, big.NewInt(0).SetUint64(testConfig.ESDTTokensToTransfer), esdtTransfers[i].ESDTValue)
+						}
+						assert.Equal(t, big.NewInt(egldTransfer.Int64()*int64(callsNumber)), egld)
+						return parentInstance
+					})
+				}),
+			test.CreateMockContract(test.ChildAddress).
+				WithBalance(testConfig.ChildBalance).
+				WithConfig(testConfig).
+				WithMethods(func(parentInstance *mock.InstanceMock, config interface{}) {
+					parentInstance.AddMockMethod("childFunction", func() *mock.InstanceMock {
+						host := parentInstance.Host
+
+						valueBytes := egldTransfer.Bytes()
+						err := host.Output().Transfer(
+							test.ParentAddress,
+							test.ChildAddress, 0, 0, big.NewInt(0).SetBytes(valueBytes), nil, []byte{}, vm.DirectCall)
+						assert.Nil(t, err)
+
+						transfer := &vmcommon.ESDTTransfer{
+							ESDTValue:      big.NewInt(int64(testConfig.ESDTTokensToTransfer)),
+							ESDTTokenName:  test.ESDTTestTokenName,
+							ESDTTokenType:  0,
+							ESDTTokenNonce: 0,
+						}
+
+						ret := vmhooks.TransferESDTNFTExecuteWithTypedArgs(
+							host,
+							test.ParentAddress,
+							[]*vmcommon.ESDTTransfer{transfer},
+							int64(testConfig.GasProvidedToChild),
+							nil,
+							nil)
+						assert.Equal(t, ret, int32(0))
+
+						return parentInstance
+					})
+				}),
+		).
+		WithSetup(func(host vmhost.VMHost, world *worldmock.MockWorld) {
+			childAccount := world.AcctMap.GetAccount(test.ChildAddress)
+			childAccount.SetBalance(egldBalance.Int64())
+			_ = childAccount.SetTokenBalanceUint64(test.ESDTTestTokenName, 0, initialESDTTokenBalance)
+			createMockBuiltinFunctions(t, host, world)
+			setZeroCodeCosts(host)
+		}).
+		WithInput(test.CreateTestContractCallInputBuilder().
+			WithRecipientAddr(test.ParentAddress).
+			WithGasProvided(testConfig.GasProvided).
+			WithFunction("callChild").
+			Build()).
+		AndAssertResults(func(world *worldmock.MockWorld, verify *test.VMOutputVerifier) {
+			verify.
+				Ok()
+		})
+	assert.Nil(t, err)
+}
+
+func Test_MultipleCalls_MultipleReads_ManagedGetBackTransfers(t *testing.T) {
+	testConfig := makeTestConfig()
+	egldBalance := big.NewInt(10)
+	egldTransfer := big.NewInt(1)
+	initialESDTTokenBalance := uint64(100)
+	testConfig.ESDTTokensToTransfer = 5
+	callsNumber := 2
+
+	_, err := test.BuildMockInstanceCallTest(t).
+		WithContracts(
+			test.CreateMockContract(test.ParentAddress).
+				WithBalance(testConfig.ParentBalance).
+				WithConfig(testConfig).
+				WithMethods(func(parentInstance *mock.InstanceMock, config interface{}) {
+					parentInstance.AddMockMethod("callChild", func() *mock.InstanceMock {
+						host := parentInstance.Host
+
+						for i := 0; i < callsNumber; i++ {
+							input := test.DefaultTestContractCallInput()
+							input.GasProvided = testConfig.GasProvidedToChild
+							input.CallerAddr = test.ParentAddress
+							input.RecipientAddr = test.ChildAddress
+							input.Function = "childFunction"
+							returnValue := contracts.ExecuteOnDestContextInMockContracts(host, input)
+							assert.Equal(t, int32(0), returnValue)
+
+							managedTypes := host.ManagedTypes()
+							esdtTransfers, egld := managedTypes.GetBackTransfers()
+							assert.Equal(t, 1, len(esdtTransfers))
+							assert.Equal(t, test.ESDTTestTokenName, esdtTransfers[0].ESDTTokenName)
+							assert.Equal(t, big.NewInt(0).SetUint64(testConfig.ESDTTokensToTransfer), esdtTransfers[0].ESDTValue)
+							assert.Equal(t, egldTransfer, egld)
+						}
+
+						return parentInstance
+					})
+				}),
+			test.CreateMockContract(test.ChildAddress).
+				WithBalance(testConfig.ChildBalance).
+				WithConfig(testConfig).
+				WithMethods(func(parentInstance *mock.InstanceMock, config interface{}) {
+					parentInstance.AddMockMethod("childFunction", func() *mock.InstanceMock {
+						host := parentInstance.Host
+
+						valueBytes := egldTransfer.Bytes()
+						err := host.Output().Transfer(
+							test.ParentAddress,
+							test.ChildAddress, 0, 0, big.NewInt(0).SetBytes(valueBytes), nil, []byte{}, vm.DirectCall)
+						assert.Nil(t, err)
+
+						transfer := &vmcommon.ESDTTransfer{
+							ESDTValue:      big.NewInt(int64(testConfig.ESDTTokensToTransfer)),
+							ESDTTokenName:  test.ESDTTestTokenName,
+							ESDTTokenType:  0,
+							ESDTTokenNonce: 0,
+						}
+
+						ret := vmhooks.TransferESDTNFTExecuteWithTypedArgs(
+							host,
+							test.ParentAddress,
+							[]*vmcommon.ESDTTransfer{transfer},
+							int64(testConfig.GasProvidedToChild),
+							nil,
+							nil)
+						assert.Equal(t, ret, int32(0))
+
+						return parentInstance
+					})
+				}),
+		).
+		WithSetup(func(host vmhost.VMHost, world *worldmock.MockWorld) {
+			childAccount := world.AcctMap.GetAccount(test.ChildAddress)
+			childAccount.SetBalance(egldBalance.Int64())
+			_ = childAccount.SetTokenBalanceUint64(test.ESDTTestTokenName, 0, initialESDTTokenBalance)
+			createMockBuiltinFunctions(t, host, world)
+			setZeroCodeCosts(host)
+		}).
+		WithInput(test.CreateTestContractCallInputBuilder().
+			WithRecipientAddr(test.ParentAddress).
+			WithGasProvided(testConfig.GasProvided).
+			WithFunction("callChild").
+			Build()).
+		AndAssertResults(func(world *worldmock.MockWorld, verify *test.VMOutputVerifier) {
+			verify.
+				Ok()
+		})
+	assert.Nil(t, err)
+}
+
 func Test_Async_ManagedGetBackTransfers(t *testing.T) {
 	testConfig := makeTestConfig()
 	initialESDTTokenBalance := uint64(100)

vmhost/interface.go

@@ -221,8 +221,7 @@ type ManagedTypesContext interface {
 	ManagedMapRemove(mMapHandle int32, keyHandle int32, outValueHandle int32) error
 	ManagedMapContains(mMapHandle int32, keyHandle int32) (bool, error)
 	GetBackTransfers() ([]*vmcommon.ESDTTransfer, *big.Int)
-	AddValueOnlyBackTransfer(value *big.Int)
-	AddBackTransfers(transfers []*vmcommon.ESDTTransfer)
+	AddBackTransfers(value *big.Int, transfers []*vmcommon.ESDTTransfer, index uint32)
 	PopBackTransferIfAsyncCallBack(vmInput *vmcommon.ContractCallInput)
 }