internal operations

chain/chaindb.go

@@ -520,7 +520,7 @@ func (cdb *ChainDB) dropBlock(dropNo types.BlockNo) error {
 	}
 
 	// remove receipt
-	cdb.deleteReceipts(&dbTx, dropBlock.BlockHash(), dropBlock.BlockNo())
+	cdb.deleteReceiptsAndOperations(&dbTx, dropBlock.BlockHash(), dropBlock.BlockNo())
 
 	// remove (hash/block)
 	dbTx.Delete(dropBlock.BlockHash())
@@ -665,6 +665,11 @@ func (cdb *ChainDB) checkExistReceipts(blockHash []byte, blockNo types.BlockNo)
 	return true
 }
 
+func (cdb *ChainDB) getInternalOperations(blockNo types.BlockNo) string {
+	data := cdb.store.Get(dbkey.InternalOps(blockNo))
+	return string(data)
+}
+
 type ChainTree struct {
 	Tree []ChainInfo
 }
@@ -691,18 +696,35 @@ func (cdb *ChainDB) GetChainTree() ([]byte, error) {
 	return jsonBytes, nil
 }
 
-func (cdb *ChainDB) writeReceipts(blockHash []byte, blockNo types.BlockNo, receipts *types.Receipts) {
+func (cdb *ChainDB) writeReceiptsAndOperations(block *types.Block, receipts *types.Receipts, internalOps string) {
+	hasReceipts := len(receipts.Get()) != 0
+	hasInternalOps := len(internalOps) != 0
+
+	if !hasReceipts && !hasInternalOps {
+		return
+	}
+
 	dbTx := cdb.store.NewTx()
 	defer dbTx.Discard()
 
-	val, _ := gob.Encode(receipts)
-	dbTx.Set(dbkey.Receipts(blockHash, blockNo), val)
+	blockHash := block.BlockHash()
+	blockNo := block.BlockNo()
+
+	if hasReceipts {
+		val, _ := gob.Encode(receipts)
+		dbTx.Set(dbkey.Receipts(blockHash, blockNo), val)
+	}
+
+	if hasInternalOps {
+		dbTx.Set(dbkey.InternalOps(blockNo), []byte(internalOps))
+	}
 
 	dbTx.Commit()
 }
 
-func (cdb *ChainDB) deleteReceipts(dbTx *db.Transaction, blockHash []byte, blockNo types.BlockNo) {
+func (cdb *ChainDB) deleteReceiptsAndOperations(dbTx *db.Transaction, blockHash []byte, blockNo types.BlockNo) {
 	(*dbTx).Delete(dbkey.Receipts(blockHash, blockNo))
+	(*dbTx).Delete(dbkey.InternalOps(blockNo))
 }
 
 func (cdb *ChainDB) writeReorgMarker(marker *ReorgMarker) error {

chain/chainhandle.go

@@ -278,6 +278,20 @@ func (cs *ChainService) listEvents(filter *types.FilterInfo) ([]*types.Event, er
 	return events, nil
 }
 
+func (cs *ChainService) getInternalOperations(blockNo types.BlockNo) (string, error) {
+	blockInMainChain, err := cs.cdb.GetBlockByNo(blockNo)
+	if err != nil {
+		return "", &ErrNoBlock{blockNo}
+	}
+
+	block, err := cs.cdb.getBlock(blockInMainChain.BlockHash())
+	if !bytes.Equal(block.BlockHash(), blockInMainChain.BlockHash()) {
+		return "", errors.New("internal operations not found")
+	}
+
+	return cs.cdb.getInternalOperations(blockNo), nil
+}
+
 type chainProcessor struct {
 	*ChainService
 	block       *types.Block // starting block
@@ -811,9 +825,7 @@ func (cs *ChainService) executeBlock(bstate *state.BlockState, block *types.Bloc
 		return err
 	}
 
-	if len(ex.BlockState.Receipts().Get()) != 0 {
-		cs.cdb.writeReceipts(block.BlockHash(), block.BlockNo(), ex.BlockState.Receipts())
-	}
+	cs.cdb.writeReceiptsAndOperations(block, ex.BlockState.Receipts(), ex.BlockState.InternalOps())
 
 	cs.notifyEvents(block, ex.BlockState)
 
@@ -1007,11 +1019,12 @@ func executeTx(execCtx context.Context, ccc consensus.ChainConsensusCluster, cdb
 
 	var txFee *big.Int
 	var rv string
+	var internalOps string
 	var events []*types.Event
 
 	switch txBody.Type {
 	case types.TxType_NORMAL, types.TxType_TRANSFER, types.TxType_CALL, types.TxType_MULTICALL, types.TxType_DEPLOY, types.TxType_REDEPLOY:
-		rv, events, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, executionMode, false)
+		rv, events, internalOps, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, executionMode, false)
 		sender.SubBalance(txFee)
 	case types.TxType_GOVERNANCE:
 		txFee = new(big.Int).SetUint64(0)
@@ -1039,7 +1052,7 @@ func executeTx(execCtx context.Context, ccc consensus.ChainConsensusCluster, cdb
 			}
 			return types.ErrNotAllowedFeeDelegation
 		}
-		rv, events, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, executionMode, true)
+		rv, events, _, txFee, err = contract.Execute(execCtx, bs, cdb, tx.GetTx(), sender, receiver, bi, executionMode, true)
 		receiver.SubBalance(txFee)
 	}
 
@@ -1094,6 +1107,10 @@ func executeTx(execCtx context.Context, ccc consensus.ChainConsensusCluster, cdb
 	}
 	bs.BpReward.Add(&bs.BpReward, txFee)
 
+	if len(internalOps) > 0 {
+		bs.AddInternalOps(internalOps)
+	}
+
 	receipt := types.NewReceipt(receiver.ID(), status, rv)
 	receipt.FeeUsed = txFee.Bytes()
 	receipt.TxHash = tx.GetHash()

chain/chainservice.go

@@ -182,6 +182,7 @@ type IChainHandler interface {
 	getReceipt(txHash []byte) (*types.Receipt, error)
 	getReceipts(blockHash []byte) (*types.Receipts, error)
 	getReceiptsByNo(blockNo types.BlockNo) (*types.Receipts, error)
+	getInternalOperations(blockNo types.BlockNo) (string, error)
 	getAccountVote(addr []byte) (*types.AccountVoteInfo, error)
 	getVotes(id string, n uint32) (*types.VoteList, error)
 	getStaking(addr []byte) (*types.Staking, error)
@@ -444,6 +445,7 @@ func (cs *ChainService) Receive(context actor.Context) {
 		*message.GetReceipt,
 		*message.GetReceipts,
 		*message.GetReceiptsByNo,
+		*message.GetInternalOperations,
 		*message.GetABI,
 		*message.GetQuery,
 		*message.GetStateQuery,
@@ -812,6 +814,12 @@ func (cw *ChainWorker) Receive(context actor.Context) {
 			Receipts: receipts,
 			Err:      err,
 		})
+	case *message.GetInternalOperations:
+		operations, err := cw.getInternalOperations(msg.BlockNo)
+		context.Respond(message.GetInternalOperationsRsp{
+			Operations: operations,
+			Err:        err,
+		})
 	case *message.GetABI:
 		sdb = cw.sdb.OpenNewStateDB(cw.sdb.GetRoot())
 		address, err := getAddressNameResolved(sdb, msg.Contract)

chain/reorg.go

@@ -491,7 +491,7 @@ func (reorg *reorganizer) rollback() error {
 func (reorg *reorganizer) deleteOldReceipts() {
 	dbTx := reorg.cs.cdb.NewTx()
 	for _, blk := range reorg.oldBlocks {
-		reorg.cs.cdb.deleteReceipts(&dbTx, blk.GetHash(), blk.BlockNo())
+		reorg.cs.cdb.deleteReceiptsAndOperations(&dbTx, blk.GetHash(), blk.BlockNo())
 	}
 	dbTx.Commit()
 }

contract/contract.go

@@ -47,7 +47,7 @@ func Execute(
 	bi *types.BlockHeaderInfo,
 	executionMode int,
 	isFeeDelegation bool,
-) (rv string, events []*types.Event, usedFee *big.Int, err error) {
+) (rv string, events []*types.Event, internalOps string, usedFee *big.Int, err error) {
 
 	var (
 		txBody     = tx.GetBody()
@@ -106,9 +106,9 @@ func Execute(
 
 	// execute the transaction
 	if receiver.IsDeploy() {
-		rv, events, ctrFee, err = Create(contractState, txPayload, receiver.ID(), ctx)
+		rv, events, internalOps, ctrFee, err = Create(contractState, txPayload, receiver.ID(), ctx)
 	} else {
-		rv, events, ctrFee, err = Call(contractState, txPayload, receiver.ID(), ctx)
+		rv, events, internalOps, ctrFee, err = Call(contractState, txPayload, receiver.ID(), ctx)
 	}
 
 	// close the trace file
@@ -118,40 +118,40 @@ func Execute(
 
 	// check if the execution fee is negative
 	if ctrFee != nil && ctrFee.Sign() < 0 {
-		return "", events, usedFee, ErrVmStart
+		return "", events, internalOps, usedFee, ErrVmStart
 	}
 	// add the execution fee to the total fee
 	usedFee.Add(usedFee, ctrFee)
 
 	// check if the execution failed
 	if err != nil {
 		if isSystemError(err) {
-			return "", events, usedFee, err
+			return "", events, internalOps, usedFee, err
 		}
-		return "", events, usedFee, newVmError(err)
+		return "", events, internalOps, usedFee, newVmError(err)
 	}
 
 	// check for sufficient balance for fee
 	if isFeeDelegation {
 		if receiver.Balance().Cmp(usedFee) < 0 {
-			return "", events, usedFee, newVmError(types.ErrInsufficientBalance)
+			return "", events, internalOps, usedFee, newVmError(types.ErrInsufficientBalance)
 		}
 	} else {
 		if sender.Balance().Cmp(usedFee) < 0 {
-			return "", events, usedFee, newVmError(types.ErrInsufficientBalance)
+			return "", events, internalOps, usedFee, newVmError(types.ErrInsufficientBalance)
 		}
 	}
 
 	if !isMultiCall {
 		// save the contract state
 		err = statedb.StageContractState(contractState, bs.StateDB)
 		if err != nil {
-			return "", events, usedFee, err
+			return "", events, internalOps, usedFee, err
 		}
 	}
 
 	// return the result
-	return rv, events, usedFee, nil
+	return rv, events, internalOps, usedFee, nil
 }
 
 // check if the tx is valid and if the code should be executed