v0.1.6

builtInFunctions/changeOwnerAddress.go

@@ -69,7 +69,16 @@ func (c *changeOwnerAddress) ProcessBuiltinFunction(
 		return nil, err
 	}
 
-	return &vmcommon.VMOutput{GasRemaining: gasRemaining, ReturnCode: vmcommon.Ok}, nil
+	vmOutput := &vmcommon.VMOutput{GasRemaining: gasRemaining, ReturnCode: vmcommon.Ok}
+	logEntry := &vmcommon.LogEntry{
+		Identifier: []byte(vmInput.Function),
+		Address:    vmInput.RecipientAddr,
+		Topics:     [][]byte{vmInput.Arguments[0]},
+	}
+	vmOutput.Logs = make([]*vmcommon.LogEntry, 0, 1)
+	vmOutput.Logs = append(vmOutput.Logs, logEntry)
+
+	return vmOutput, nil
 }
 
 func computeGasRemaining(snd vmcommon.UserAccountHandler, gasProvided uint64, gasToUse uint64) uint64 {

builtInFunctions/changeOwnerAddress_test.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/Dharitri-org/drtg-core/core"
 	"github.com/Dharitri-org/drtg-core/core/check"
 	vmcommon "github.com/Dharitri-org/drtg-vm-common"
 	"github.com/Dharitri-org/drtg-vm-common/mock"
@@ -42,7 +43,8 @@ func TestChangeOwnerAddress_ProcessBuiltinFunction(t *testing.T) {
 
 	acc := mock.NewUserAccount(addr)
 	vmInput := &vmcommon.ContractCallInput{
-		VMInput: vmcommon.VMInput{CallerAddr: owner, CallValue: big.NewInt(0)},
+		Function: core.BuiltInFunctionChangeOwnerAddress,
+		VMInput:  vmcommon.VMInput{CallerAddr: owner, CallValue: big.NewInt(0)},
 	}
 
 	_, err := coa.ProcessBuiltinFunction(nil, acc, vmInput)
@@ -63,10 +65,18 @@ func TestChangeOwnerAddress_ProcessBuiltinFunction(t *testing.T) {
 	require.Nil(t, err)
 	require.Equal(t, vmOutput.GasRemaining, uint64(0))
 
+	contractAddress := []byte("contract")
+	vmInput.RecipientAddr = contractAddress
 	coa.gasCost = 1
 	vmInput.GasProvided = 10
 	acc.OwnerAddress = owner
 	vmOutput, err = coa.ProcessBuiltinFunction(acc, acc, vmInput)
 	require.Nil(t, err)
 	require.Equal(t, vmOutput.GasRemaining, vmInput.GasProvided-coa.gasCost)
+
+	require.Equal(t, &vmcommon.LogEntry{
+		Identifier: []byte(core.BuiltInFunctionChangeOwnerAddress),
+		Address:    contractAddress,
+		Topics:     [][]byte{newAddr},
+	}, vmOutput.Logs[0])
 }

builtInFunctions/dctNFTTransfer.go

@@ -189,7 +189,16 @@ func (e *dctNFTTransfer) ProcessBuiltinFunction(
 			vmOutput)
 	}
 
-	addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionDCTNFTTransfer), vmInput.Arguments[0], nonce, value, vmInput.CallerAddr, acntDst.AddressBytes())
+	addDCTEntryForTransferInVMOutput(
+		vmInput, vmOutput,
+		[]byte(core.BuiltInFunctionDCTNFTTransfer),
+		acntDst.AddressBytes(),
+		[]*TopicTokenData{{
+			vmInput.Arguments[0],
+			nonce,
+			value,
+		}},
+	)
 
 	return vmOutput, nil
 }
@@ -297,7 +306,16 @@ func (e *dctNFTTransfer) processNFTTransferOnSenderShard(
 		return nil, err
 	}
 
-	addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionDCTNFTTransfer), vmInput.Arguments[0], nonce, quantityToTransfer, vmInput.CallerAddr, dstAddress)
+	addDCTEntryForTransferInVMOutput(
+		vmInput, vmOutput,
+		[]byte(core.BuiltInFunctionDCTNFTTransfer),
+		dstAddress,
+		[]*TopicTokenData{{
+			vmInput.Arguments[0],
+			nonce,
+			quantityToTransfer,
+		}},
+	)
 
 	return vmOutput, nil
 }

builtInFunctions/dctTransfer.go

@@ -163,7 +163,16 @@ func (e *dctTransfer) ProcessBuiltinFunction(
 				vmInput.CallType,
 				vmOutput)
 
-			addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionDCTTransfer), tokenID, 0, value, vmInput.CallerAddr, acntDst.AddressBytes())
+			addDCTEntryForTransferInVMOutput(
+				vmInput, vmOutput,
+				[]byte(core.BuiltInFunctionDCTTransfer),
+				acntDst.AddressBytes(),
+				[]*TopicTokenData{{
+					tokenID,
+					0,
+					value,
+				}},
+			)
 			return vmOutput, nil
 		}
 
@@ -172,7 +181,15 @@ func (e *dctTransfer) ProcessBuiltinFunction(
 			vmOutput.GasRemaining = vmInput.GasProvided
 		}
 
-		addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionDCTTransfer), tokenID, 0, value, vmInput.CallerAddr, acntDst.AddressBytes())
+		addDCTEntryForTransferInVMOutput(
+			vmInput, vmOutput,
+			[]byte(core.BuiltInFunctionDCTTransfer),
+			acntDst.AddressBytes(),
+			[]*TopicTokenData{{
+				tokenID,
+				0,
+				value,
+			}})
 		return vmOutput, nil
 	}
 
@@ -189,7 +206,15 @@ func (e *dctTransfer) ProcessBuiltinFunction(
 			vmOutput)
 	}
 
-	addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionDCTTransfer), tokenID, 0, value, vmInput.CallerAddr, vmInput.RecipientAddr)
+	addDCTEntryForTransferInVMOutput(
+		vmInput, vmOutput,
+		[]byte(core.BuiltInFunctionDCTTransfer),
+		vmInput.RecipientAddr,
+		[]*TopicTokenData{{
+			tokenID,
+			0,
+			value,
+		}})
 	return vmOutput, nil
 }
 

builtInFunctions/logsAndEvents.go

@@ -14,6 +14,42 @@ const (
 	dctRandomSequenceLength = 6
 )
 
+// TopicTokenData groups data that will end up in Topics section of LogEntry
+type TopicTokenData struct {
+	TokenID []byte
+	Nonce   uint64
+	Value   *big.Int
+}
+
+func addDCTEntryForTransferInVMOutput(
+	vmInput *vmcommon.ContractCallInput,
+	vmOutput *vmcommon.VMOutput,
+	identifier []byte,
+	destination []byte,
+	topicTokenData []*TopicTokenData,
+) {
+
+	topicTokenBytes := make([][]byte, 0)
+	for _, tokenData := range topicTokenData {
+		nonceBig := big.NewInt(0).SetUint64(tokenData.Nonce)
+		topicTokenBytes = append(topicTokenBytes, tokenData.TokenID, nonceBig.Bytes(), tokenData.Value.Bytes())
+	}
+	topicTokenBytes = append(topicTokenBytes, destination)
+
+	logEntry := &vmcommon.LogEntry{
+		Identifier: identifier,
+		Address:    vmInput.CallerAddr,
+		Topics:     topicTokenBytes,
+		Data:       vmcommon.FormatLogDataForCall("", vmInput.Function, vmInput.Arguments),
+	}
+
+	if vmOutput.Logs == nil {
+		vmOutput.Logs = make([]*vmcommon.LogEntry, 0, 1)
+	}
+
+	vmOutput.Logs = append(vmOutput.Logs, logEntry)
+}
+
 func addDCTEntryInVMOutput(vmOutput *vmcommon.VMOutput, identifier []byte, tokenID []byte, nonce uint64, value *big.Int, args ...[]byte) {
 	entry := newEntryForDCT(identifier, tokenID, nonce, value, args...)
 

builtInFunctions/multiDCTNFTTransfer.go

@@ -162,6 +162,7 @@ func (e *dctNFTMultiTransfer) ProcessBuiltinFunction(
 		return nil, err
 	}
 
+	topicTokenData := make([]*TopicTokenData, 0)
 	for i := uint64(0); i < numOfTransfers; i++ {
 		tokenStartIndex := startIndex + i*argumentsPerTransfer
 		tokenID := vmInput.Arguments[tokenStartIndex]
@@ -204,7 +205,31 @@ func (e *dctNFTMultiTransfer) ProcessBuiltinFunction(
 			}
 		}
 
-		addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionMultiDCTNFTTransfer), tokenID, nonce, value, vmInput.CallerAddr, acntDst.AddressBytes())
+		if e.enableEpochsHandler.IsScToScEventLogEnabled() {
+			topicTokenData = append(topicTokenData,
+				&TopicTokenData{
+					tokenID,
+					nonce,
+					value,
+				})
+		} else {
+			addDCTEntryInVMOutput(vmOutput,
+				[]byte(core.BuiltInFunctionMultiDCTNFTTransfer),
+				tokenID,
+				nonce,
+				value,
+				vmInput.CallerAddr,
+				acntDst.AddressBytes())
+		}
+	}
+
+	if e.enableEpochsHandler.IsScToScEventLogEnabled() {
+		addDCTEntryForTransferInVMOutput(
+			vmInput, vmOutput,
+			[]byte(core.BuiltInFunctionMultiDCTNFTTransfer),
+			acntDst.AddressBytes(),
+			topicTokenData,
+		)
 	}
 
 	// no need to consume gas on destination - sender already paid for it
@@ -280,6 +305,7 @@ func (e *dctNFTMultiTransfer) processDCTNFTMultiTransferOnSenderShard(
 	listDctData := make([]*dct.DCToken, numOfTransfers)
 	listTransferData := make([]*vmcommon.DCTTransfer, numOfTransfers)
 
+	topicTokenData := make([]*TopicTokenData, 0)
 	for i := uint64(0); i < numOfTransfers; i++ {
 		tokenStartIndex := startIndex + i*argumentsPerTransfer
 		if len(vmInput.Arguments[tokenStartIndex+2]) > core.MaxLenForDCTIssueMint && e.enableEpochsHandler.IsConsistentTokensValuesLengthCheckEnabled() {
@@ -308,7 +334,31 @@ func (e *dctNFTMultiTransfer) processDCTNFTMultiTransferOnSenderShard(
 			return nil, fmt.Errorf("%w for token %s", err, string(listTransferData[i].DCTTokenName))
 		}
 
-		addDCTEntryInVMOutput(vmOutput, []byte(core.BuiltInFunctionMultiDCTNFTTransfer), listTransferData[i].DCTTokenName, listTransferData[i].DCTTokenNonce, listTransferData[i].DCTValue, vmInput.CallerAddr, dstAddress)
+		if e.enableEpochsHandler.IsScToScEventLogEnabled() {
+			topicTokenData = append(topicTokenData,
+				&TopicTokenData{
+					listTransferData[i].DCTTokenName,
+					listTransferData[i].DCTTokenNonce,
+					listTransferData[i].DCTValue,
+				})
+		} else {
+			addDCTEntryInVMOutput(vmOutput,
+				[]byte(core.BuiltInFunctionMultiDCTNFTTransfer),
+				listTransferData[i].DCTTokenName,
+				listTransferData[i].DCTTokenNonce,
+				listTransferData[i].DCTValue,
+				vmInput.CallerAddr,
+				dstAddress)
+		}
+	}
+
+	if e.enableEpochsHandler.IsScToScEventLogEnabled() {
+		addDCTEntryForTransferInVMOutput(
+			vmInput, vmOutput,
+			[]byte(core.BuiltInFunctionMultiDCTNFTTransfer),
+			dstAddress,
+			topicTokenData,
+		)
 	}
 
 	if !check.IfNil(acntDst) {

builtInFunctions/multiDCTNFTTransfer_test.go

@@ -66,6 +66,10 @@ func createAccountsAdapterWithMap() vmcommon.AccountsAdapter {
 }
 
 func createDCTNFTMultiTransferWithMockArguments(selfShard uint32, numShards uint32, globalSettingsHandler vmcommon.ExtendedDCTGlobalSettingsHandler) *dctNFTMultiTransfer {
+	return createDCTNFTMultiTransferWithMockArgumentsWithLogEventFlag(selfShard, numShards, globalSettingsHandler, false)
+}
+
+func createDCTNFTMultiTransferWithMockArgumentsWithLogEventFlag(selfShard uint32, numShards uint32, globalSettingsHandler vmcommon.ExtendedDCTGlobalSettingsHandler, isScToScEventLogEnabled bool) *dctNFTMultiTransfer {
 	marshaller := &mock.MarshalizerMock{}
 	shardCoordinator := mock.NewMultiShardsCoordinatorMock(numShards)
 	shardCoordinator.CurrentShard = selfShard
@@ -79,6 +83,7 @@ func createDCTNFTMultiTransferWithMockArguments(selfShard uint32, numShards uint
 		IsDCTNFTImprovementV1FlagEnabledField:                true,
 		IsTransferToMetaFlagEnabledField:                     false,
 		IsCheckCorrectTokenIDForTransferRoleFlagEnabledField: true,
+		IsScToScEventLogEnabledField:                         isScToScEventLogEnabled,
 	}
 	multiTransfer, _ := NewDCTNFTMultiTransferFunc(
 		1,
@@ -1104,3 +1109,81 @@ func TestComputeInsufficientQuantityDCTError(t *testing.T) {
 	require.NotNil(t, resErr)
 	require.Equal(t, errors.New("insufficient quantity for token: my-token-2 nonce 5").Error(), resErr.Error())
 }
+
+func TestDCTNFTMultiTransfer_LogEventsEpochActivationTest(t *testing.T) {
+	t.Parallel()
+
+	vmOutput, err := runMultiTransfer(t, false)
+	require.Nil(t, err)
+	require.Equal(t, vmcommon.Ok, vmOutput.ReturnCode)
+
+	require.Equal(t, 2, len(vmOutput.Logs))
+	require.Equal(t, []byte("MultiDCTNFTTransfer"), vmOutput.Logs[0].Identifier)
+	require.Equal(t, 4, len(vmOutput.Logs[0].Topics))
+	require.Equal(t, []byte("token1"), vmOutput.Logs[0].Topics[0])
+	require.Equal(t, []byte("MultiDCTNFTTransfer"), vmOutput.Logs[1].Identifier)
+	require.Equal(t, 4, len(vmOutput.Logs[1].Topics))
+	require.Equal(t, []byte("token2"), vmOutput.Logs[1].Topics[0])
+
+	vmOutput, err = runMultiTransfer(t, true)
+	require.Nil(t, err)
+	require.Equal(t, vmcommon.Ok, vmOutput.ReturnCode)
+
+	require.Equal(t, 1, len(vmOutput.Logs))
+	require.Equal(t, []byte("MultiDCTNFTTransfer"), vmOutput.Logs[0].Identifier)
+	require.Equal(t, 7, len(vmOutput.Logs[0].Topics))
+	require.Equal(t, []byte("token1"), vmOutput.Logs[0].Topics[0])
+	require.Equal(t, []byte("token2"), vmOutput.Logs[0].Topics[3])
+}
+
+func runMultiTransfer(t *testing.T, isScToScEventLogEnabled bool) (*vmcommon.VMOutput, error) {
+	payableHandler := &mock.PayableHandlerStub{
+		IsPayableCalled: func(address []byte) (bool, error) {
+			return true, nil
+		},
+	}
+
+	multiTransferSenderShard := createDCTNFTMultiTransferWithMockArgumentsWithLogEventFlag(0, 2, &mock.GlobalSettingsHandlerStub{}, isScToScEventLogEnabled)
+	_ = multiTransferSenderShard.SetPayableChecker(payableHandler)
+
+	multiTransferDestinationShard := createDCTNFTMultiTransferWithMockArgumentsWithLogEventFlag(1, 2, &mock.GlobalSettingsHandlerStub{}, isScToScEventLogEnabled)
+	_ = multiTransferDestinationShard.SetPayableChecker(payableHandler)
+
+	senderAddress := bytes.Repeat([]byte{2}, 32) // sender is in the same shard
+	destinationAddress := bytes.Repeat([]byte{1}, 32)
+	sender, err := multiTransferSenderShard.accounts.LoadAccount(senderAddress)
+	require.Nil(t, err)
+
+	token1 := []byte("token1")
+	token2 := []byte("token2")
+	tokenNonce := uint64(1)
+	token2Nonce := uint64(2)
+
+	initialTokens := big.NewInt(3)
+	createDCTNFTToken(token1, core.NonFungible, tokenNonce, initialTokens, multiTransferSenderShard.marshaller, sender.(vmcommon.UserAccountHandler))
+	createDCTNFTToken(token2, core.NonFungible, token2Nonce, initialTokens, multiTransferSenderShard.marshaller, sender.(vmcommon.UserAccountHandler))
+
+	_ = multiTransferSenderShard.accounts.SaveAccount(sender)
+	_, _ = multiTransferSenderShard.accounts.Commit()
+
+	// reload sender account
+	sender, err = multiTransferSenderShard.accounts.LoadAccount(senderAddress)
+	require.Nil(t, err)
+
+	nonceBytes := big.NewInt(int64(tokenNonce)).Bytes()
+	nonce2Bytes := big.NewInt(int64(token2Nonce)).Bytes()
+	quantityBytes := big.NewInt(1).Bytes()
+	vmInput := &vmcommon.ContractCallInput{
+		VMInput: vmcommon.VMInput{
+			CallValue:  big.NewInt(0),
+			CallerAddr: senderAddress,
+			Arguments: [][]byte{destinationAddress, big.NewInt(2).Bytes(),
+				token1, nonceBytes, quantityBytes,
+				token2, nonce2Bytes, quantityBytes},
+			GasProvided: 100000,
+		},
+		RecipientAddr: senderAddress,
+	}
+
+	return multiTransferSenderShard.ProcessBuiltinFunction(sender.(vmcommon.UserAccountHandler), nil, vmInput)
+}