split transaction log and action log (iotexproject#2354)

* split transaction log and action log

Co-authored-by: Yutong Pei <[email protected]>

Author: CoderZhi

action/protocol/account/protocol.go

@@ -32,7 +32,7 @@ type Protocol struct {
 }
 
 // DepositGas deposits gas to some pool
-type DepositGas func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.Log, error)
+type DepositGas func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error)
 
 // NewProtocol instantiates the protocol of account
 func NewProtocol(depositGas DepositGas) *Protocol {

action/protocol/account/transfer.go

@@ -51,7 +51,7 @@ func (p *Protocol) handleTransfer(ctx context.Context, act action.Action, sm pro
 		)
 	}
 
-	var depositLog *action.Log
+	var depositLog *action.TransactionLog
 	hu := config.NewHeightUpgrade(&bcCtx.Genesis)
 	if hu.IsPre(config.Pacific, blkCtx.BlockHeight) {
 		// charge sender gas
@@ -93,7 +93,7 @@ func (p *Protocol) handleTransfer(ctx context.Context, act action.Action, sm pro
 			GasConsumed:     actionCtx.IntrinsicGas,
 			ContractAddress: p.addr.String(),
 		}
-		receipt.AddLogs(depositLog)
+		receipt.AddTransactionLogs(depositLog)
 		return receipt, nil
 	}
 
@@ -136,13 +136,11 @@ func (p *Protocol) handleTransfer(ctx context.Context, act action.Action, sm pro
 		GasConsumed:     actionCtx.IntrinsicGas,
 		ContractAddress: p.addr.String(),
 	}
-	receipt.AddLogs(&action.Log{
-		TransactionData: &action.TransactionLog{
-			Type:      iotextypes.TransactionLogType_NATIVE_TRANSFER,
-			Sender:    actionCtx.Caller.String(),
-			Recipient: tsf.Recipient(),
-			Amount:    tsf.Amount(),
-		},
+	receipt.AddTransactionLogs(&action.TransactionLog{
+		Type:      iotextypes.TransactionLogType_NATIVE_TRANSFER,
+		Sender:    actionCtx.Caller.String(),
+		Recipient: tsf.Recipient(),
+		Amount:    tsf.Amount(),
 	}, depositLog)
 
 	return receipt, nil

action/protocol/execution/evm/evm.go

@@ -185,7 +185,7 @@ func ExecuteContract(
 	}
 
 	receipt.Status = statusCode
-	var burnLog *action.Log
+	var burnLog *action.TransactionLog
 	if hu.IsPost(config.Pacific, blkCtx.BlockHeight) {
 		// Refund all deposit and, actual gas fee will be subtracted when depositing gas fee to the rewarding protocol
 		stateDB.AddBalance(ps.context.Origin, big.NewInt(0).Mul(big.NewInt(0).SetUint64(depositGas), ps.context.GasPrice))
@@ -195,20 +195,15 @@ func ExecuteContract(
 			stateDB.AddBalance(ps.context.Origin, remainingValue)
 		}
 		if depositGas-remainingGas > 0 {
-			burnLog = &action.Log{
-				Address:     contractAddress,
-				BlockHeight: blkCtx.BlockHeight,
-				ActionHash:  execution.Hash(),
-				TransactionData: &action.TransactionLog{
-					Type:      iotextypes.TransactionLogType_GAS_FEE,
-					Sender:    actionCtx.Caller.String(),
-					Recipient: "", // burned
-					Amount:    new(big.Int).Mul(new(big.Int).SetUint64(depositGas-remainingGas), ps.context.GasPrice),
-				},
+			burnLog = &action.TransactionLog{
+				Type:      iotextypes.TransactionLogType_GAS_FEE,
+				Sender:    actionCtx.Caller.String(),
+				Recipient: "", // burned
+				Amount:    new(big.Int).Mul(new(big.Int).SetUint64(depositGas-remainingGas), ps.context.GasPrice),
 			}
 		}
 	}
-	var depositLog *action.Log
+	var depositLog *action.TransactionLog
 	if depositGas-remainingGas > 0 {
 		gasValue := new(big.Int).Mul(new(big.Int).SetUint64(depositGas-remainingGas), ps.context.GasPrice)
 		depositLog, err = depositGasFunc(ctx, sm, gasValue)
@@ -221,8 +216,7 @@ func ExecuteContract(
 		return nil, nil, errors.Wrap(err, "failed to commit contracts to underlying db")
 	}
 	stateDB.clear()
-	receipt.AddLogs(stateDB.Logs()...)
-	receipt.AddLogs(depositLog, burnLog)
+	receipt.AddLogs(stateDB.Logs()...).AddTransactionLogs(stateDB.TransactionLogs()...).AddTransactionLogs(depositLog, burnLog)
 	log.S().Debugf("Receipt: %+v, %v", receipt, err)
 	return retval, receipt, nil
 }
@@ -377,7 +371,7 @@ func SimulateExecution(
 		sm,
 		ex,
 		getBlockHash,
-		func(context.Context, protocol.StateManager, *big.Int) (*action.Log, error) {
+		func(context.Context, protocol.StateManager, *big.Int) (*action.TransactionLog, error) {
 			return nil, nil
 		},
 	)

action/protocol/execution/evm/evm_test.go

@@ -60,7 +60,7 @@ func TestExecuteContractFailure(t *testing.T) {
 		func(uint64) (hash.Hash256, error) {
 			return hash.ZeroHash256, nil
 		},
-		func(context.Context, protocol.StateManager, *big.Int) (*action.Log, error) {
+		func(context.Context, protocol.StateManager, *big.Int) (*action.TransactionLog, error) {
 			return nil, nil
 		})
 	require.Nil(t, retval)

action/protocol/execution/evm/evmstatedbadapter.go

@@ -45,12 +45,13 @@ type (
 	GetBlockHash func(uint64) (hash.Hash256, error)
 
 	// DepositGas deposits gas
-	DepositGas func(context.Context, protocol.StateManager, *big.Int) (*action.Log, error)
+	DepositGas func(context.Context, protocol.StateManager, *big.Int) (*action.TransactionLog, error)
 
 	// StateDBAdapter represents the state db adapter for evm to access iotx blockchain
 	StateDBAdapter struct {
 		sm                 protocol.StateManager
 		logs               []*action.Log
+		transactionLogs    []*action.TransactionLog
 		err                error
 		blockHeight        uint64
 		executionHash      hash.Hash256
@@ -425,33 +426,41 @@ func (stateDB *StateDBAdapter) AddLog(evmLog *types.Log) {
 		copy(topic[:], evmTopic.Bytes())
 		topics = append(topics, topic)
 	}
-	log := &action.Log{
+	if topics[0] == inContractTransfer {
+		if len(topics) != 3 {
+			panic("Invalid in contract transfer topics")
+		}
+		from, _ := address.FromBytes(topics[1][12:])
+		to, _ := address.FromBytes(topics[2][12:])
+		stateDB.transactionLogs = append(stateDB.transactionLogs, &action.TransactionLog{
+			Type:      iotextypes.TransactionLogType_IN_CONTRACT_TRANSFER,
+			Sender:    from.String(),
+			Recipient: to.String(),
+			Amount:    new(big.Int).SetBytes(evmLog.Data),
+		})
+		return
+	}
+
+	stateDB.logs = append(stateDB.logs, &action.Log{
 		Address:            addr.String(),
 		Topics:             topics,
 		Data:               evmLog.Data,
 		BlockHeight:        stateDB.blockHeight,
 		ActionHash:         stateDB.executionHash,
 		NotFixTopicCopyBug: stateDB.notFixTopicCopyBug,
-	}
-
-	if len(topics) >= 3 && topics[0] == inContractTransfer {
-		from, _ := address.FromBytes(log.Topics[1][12:])
-		to, _ := address.FromBytes(log.Topics[2][12:])
-		log.TransactionData = &action.TransactionLog{
-			Type:      iotextypes.TransactionLogType_IN_CONTRACT_TRANSFER,
-			Sender:    from.String(),
-			Recipient: to.String(),
-			Amount:    new(big.Int).SetBytes(log.Data),
-		}
-	}
-	stateDB.logs = append(stateDB.logs, log)
+	})
 }
 
 // Logs returns the logs
 func (stateDB *StateDBAdapter) Logs() []*action.Log {
 	return stateDB.logs
 }
 
+// TransactionLogs returns the transaction logs
+func (stateDB *StateDBAdapter) TransactionLogs() []*action.TransactionLog {
+	return stateDB.transactionLogs
+}
+
 // AddPreimage adds the preimage of a hash
 func (stateDB *StateDBAdapter) AddPreimage(hash common.Hash, preimage []byte) {
 	if _, ok := stateDB.preimages[hash]; !ok {

action/protocol/execution/protocol_test.go

@@ -490,13 +490,7 @@ func (sct *SmartContractTest) run(r *require.Assertions) {
 			)
 		}
 		if receipt.Status == uint64(iotextypes.ReceiptStatus_Success) {
-			numLog := 0
-			for _, l := range receipt.Logs {
-				if !l.IsTransactionLog() {
-					numLog++
-				}
-			}
-			r.Equal(len(exec.ExpectedLogs), numLog, i)
+			r.Equal(len(exec.ExpectedLogs), len(receipt.Logs()), i)
 			// TODO: check value of logs
 		}
 	}

action/protocol/poll/consortium.go

@@ -129,7 +129,7 @@ func (cc *consortiumCommittee) CreateGenesisStates(ctx context.Context, sm proto
 		func(height uint64) (hash.Hash256, error) {
 			return hash.ZeroHash256, nil
 		},
-		func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.Log, error) {
+		func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error) {
 			return nil, nil
 		},
 	)

action/protocol/poll/staking_committee.go

@@ -140,7 +140,7 @@ func (sc *stakingCommittee) CreateGenesisStates(ctx context.Context, sm protocol
 		func(height uint64) (hash.Hash256, error) {
 			return hash.ZeroHash256, nil
 		},
-		func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.Log, error) {
+		func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error) {
 			return nil, nil
 		},
 	)

action/protocol/rewarding/fund.go

@@ -64,9 +64,8 @@ func (p *Protocol) Deposit(
 	sm protocol.StateManager,
 	amount *big.Int,
 	transactionLogType iotextypes.TransactionLogType,
-) (*action.Log, error) {
+) (*action.TransactionLog, error) {
 	actionCtx := protocol.MustGetActionCtx(ctx)
-	blkCtx := protocol.MustGetBlockCtx(ctx)
 	if err := p.assertAmount(amount); err != nil {
 		return nil, err
 	}
@@ -92,16 +91,11 @@ func (p *Protocol) Deposit(
 	if err := p.putState(ctx, sm, fundKey, &f); err != nil {
 		return nil, err
 	}
-	return &action.Log{
-		Address:     p.addr.String(),
-		BlockHeight: blkCtx.BlockHeight,
-		ActionHash:  actionCtx.ActionHash,
-		TransactionData: &action.TransactionLog{
-			Type:      transactionLogType,
-			Sender:    actionCtx.Caller.String(),
-			Recipient: address.RewardingPoolAddr,
-			Amount:    amount,
-		},
+	return &action.TransactionLog{
+		Type:      transactionLogType,
+		Sender:    actionCtx.Caller.String(),
+		Recipient: address.RewardingPoolAddr,
+		Amount:    amount,
 	}, nil
 }
 
@@ -147,7 +141,7 @@ func (p *Protocol) assertEnoughBalance(
 }
 
 // DepositGas deposits gas into the rewarding fund
-func DepositGas(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.Log, error) {
+func DepositGas(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error) {
 	// If the gas fee is 0, return immediately
 	if amount.Cmp(big.NewInt(0)) == 0 {
 		return nil, nil

action/protocol/rewarding/fund_test.go

@@ -31,10 +31,9 @@ func TestProtocol_Fund(t *testing.T) {
 		rlog, err := p.Deposit(ctx, sm, big.NewInt(5), iotextypes.TransactionLogType_DEPOSIT_TO_REWARDING_FUND)
 		require.NoError(t, err)
 		require.NotNil(t, rlog)
-		require.True(t, rlog.IsTransactionLog())
-		require.Equal(t, big.NewInt(5).String(), rlog.TransactionData.Amount.String())
-		require.Equal(t, actionCtx.Caller.String(), rlog.TransactionData.Sender)
-		require.Equal(t, address.RewardingPoolAddr, rlog.TransactionData.Recipient)
+		require.Equal(t, big.NewInt(5).String(), rlog.Amount.String())
+		require.Equal(t, actionCtx.Caller.String(), rlog.Sender)
+		require.Equal(t, address.RewardingPoolAddr, rlog.Recipient)
 
 		totalBalance, _, err := p.TotalBalance(ctx, sm)
 		require.NoError(t, err)

action/protocol/rewarding/protocol.go

@@ -162,38 +162,38 @@ func (p *Protocol) Handle(
 		rlog, err := p.Deposit(ctx, sm, act.Amount(), iotextypes.TransactionLogType_DEPOSIT_TO_REWARDING_FUND)
 		if err != nil {
 			log.L().Debug("Error when handling rewarding action", zap.Error(err))
-			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si)
+			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si, nil)
 		}
-		return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, rlog)
+		return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, nil, rlog)
 	case *action.ClaimFromRewardingFund:
 		si := sm.Snapshot()
 		rlog, err := p.Claim(ctx, sm, act.Amount())
 		if err != nil {
 			log.L().Debug("Error when handling rewarding action", zap.Error(err))
-			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si)
+			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si, nil)
 		}
-		return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, rlog)
+		return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, nil, rlog)
 	case *action.GrantReward:
 		switch act.RewardType() {
 		case action.BlockReward:
 			si := sm.Snapshot()
 			rewardLog, err := p.GrantBlockReward(ctx, sm)
 			if err != nil {
 				log.L().Debug("Error when handling rewarding action", zap.Error(err))
-				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si)
+				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si, nil)
 			}
 			if rewardLog == nil {
-				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si)
+				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, nil)
 			}
-			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, rewardLog)
+			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, []*action.Log{rewardLog})
 		case action.EpochReward:
 			si := sm.Snapshot()
 			rewardLogs, err := p.GrantEpochReward(ctx, sm)
 			if err != nil {
 				log.L().Debug("Error when handling rewarding action", zap.Error(err))
-				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si)
+				return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Failure), si, nil)
 			}
-			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, rewardLogs...)
+			return p.settleAction(ctx, sm, uint64(iotextypes.ReceiptStatus_Success), si, rewardLogs)
 		}
 	}
 	return nil, nil
@@ -337,7 +337,8 @@ func (p *Protocol) settleAction(
 	sm protocol.StateManager,
 	status uint64,
 	si int,
-	logs ...*action.Log,
+	logs []*action.Log,
+	tLogs ...*action.TransactionLog,
 ) (*action.Receipt, error) {
 	actionCtx := protocol.MustGetActionCtx(ctx)
 	blkCtx := protocol.MustGetBlockCtx(ctx)
@@ -352,12 +353,12 @@ func (p *Protocol) settleAction(
 		return nil, err
 	}
 	if depositLog != nil {
-		logs = append(logs, depositLog)
+		tLogs = append(tLogs, depositLog)
 	}
 	if err := p.increaseNonce(sm, actionCtx.Caller, actionCtx.Nonce); err != nil {
 		return nil, err
 	}
-	return p.createReceipt(status, blkCtx.BlockHeight, actionCtx.ActionHash, actionCtx.IntrinsicGas, logs...), nil
+	return p.createReceipt(status, blkCtx.BlockHeight, actionCtx.ActionHash, actionCtx.IntrinsicGas, logs, tLogs...), nil
 }
 
 func (p *Protocol) increaseNonce(sm protocol.StateManager, addr address.Address, nonce uint64) error {
@@ -377,16 +378,15 @@ func (p *Protocol) createReceipt(
 	blkHeight uint64,
 	actHash hash.Hash256,
 	gasConsumed uint64,
-	logs ...*action.Log,
+	logs []*action.Log,
+	tLogs ...*action.TransactionLog,
 ) *action.Receipt {
 	// TODO: need to review the fields
-	r := &action.Receipt{
+	return (&action.Receipt{
 		Status:          status,
 		BlockHeight:     blkHeight,
 		ActionHash:      actHash,
 		GasConsumed:     gasConsumed,
 		ContractAddress: p.addr.String(),
-	}
-	r.AddLogs(logs...)
-	return r
+	}).AddLogs(logs...).AddTransactionLogs(tLogs...)
 }

action/protocol/rewarding/protocol_test.go

@@ -371,7 +371,7 @@ func TestProtocol_Handle(t *testing.T) {
 	receipt, err = p.Handle(ctx, se2.Action(), sm)
 	require.NoError(t, err)
 	assert.Equal(t, uint64(iotextypes.ReceiptStatus_Success), receipt.Status)
-	assert.Equal(t, 1, len(receipt.Logs))
+	assert.Equal(t, 1, len(receipt.Logs()))
 	// Grant the block reward again should fail
 	receipt, err = p.Handle(ctx, se2.Action(), sm)
 	require.NoError(t, err)