feat: add cross-chain output (#56)

[bytom/vapor.git] / mining / mining.go

diff --git a/mining/mining.go b/mining/mining.go
index 5943904..9f9dece 100644 (file)
--- a/mining/mining.go
+++ b/mining/mining.go
@@ -5,16 +5,11 @@ import (
        "strconv"
        "time"
 
-       "github.com/vapor/common"
-
        log "github.com/sirupsen/logrus"
 
        "github.com/vapor/account"
        "github.com/vapor/blockchain/txbuilder"
-       "github.com/vapor/config"
        "github.com/vapor/consensus"
-       engine "github.com/vapor/consensus/consensus"
-       "github.com/vapor/crypto/ed25519/chainkd"
        "github.com/vapor/errors"
        "github.com/vapor/protocol"
        "github.com/vapor/protocol/bc"
@@ -24,26 +19,22 @@ import (
        "github.com/vapor/protocol/vm/vmutil"
 )
 
+const logModule = "mining"
+
 // createCoinbaseTx returns a coinbase transaction paying an appropriate subsidy
 // based on the passed block height to the provided address.  When the address
 // is nil, the coinbase transaction will instead be redeemable by anyone.
 func createCoinbaseTx(accountManager *account.Manager, amount uint64, blockHeight uint64) (tx *types.Tx, err error) {
-       //amount += consensus.BlockSubsidy(blockHeight)
+       amount += consensus.BlockSubsidy(blockHeight)
        arbitrary := append([]byte{0x00}, []byte(strconv.FormatUint(blockHeight, 10))...)
 
        var script []byte
-       address, _ := common.DecodeAddress(config.CommonConfig.Consensus.Dpos.Coinbase, &consensus.ActiveNetParams)
-       redeemContract := address.ScriptAddress()
-       script, _ = vmutil.P2WPKHProgram(redeemContract)
-       /*
-               if accountManager == nil {
-                       script, err = vmutil.DefaultCoinbaseProgram()
-               } else {
-
-                       script, err = accountManager.GetCoinbaseControlProgram()
-                       arbitrary = append(arbitrary, accountManager.GetCoinbaseArbitrary()...)
-               }
-       */
+       if accountManager == nil {
+               script, err = vmutil.DefaultCoinbaseProgram()
+       } else {
+               script, err = accountManager.GetCoinbaseControlProgram()
+               arbitrary = append(arbitrary, accountManager.GetCoinbaseArbitrary()...)
+       }
        if err != nil {
                return nil, err
        }
@@ -56,7 +47,7 @@ func createCoinbaseTx(accountManager *account.Manager, amount uint64, blockHeigh
        if err = builder.AddInput(types.NewCoinbaseInput(arbitrary), &txbuilder.SigningInstruction{}); err != nil {
                return nil, err
        }
-       if err = builder.AddOutput(types.NewTxOutput(*consensus.BTMAssetID, amount, script)); err != nil {
+       if err = builder.AddOutput(types.NewIntraChainOutput(*consensus.BTMAssetID, amount, script)); err != nil {
                return nil, err
        }
        _, txData, err := builder.Build()
@@ -78,7 +69,7 @@ func createCoinbaseTx(accountManager *account.Manager, amount uint64, blockHeigh
 }
 
 // NewBlockTemplate returns a new block template that is ready to be solved
-func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager *account.Manager, engine engine.Engine) (b *types.Block, err error) {
+func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager *account.Manager) (b *types.Block, err error) {
        view := state.NewUtxoViewpoint()
        txStatus := bc.NewTransactionStatus()
        if err := txStatus.SetStatus(0, false); err != nil {
@@ -93,29 +84,15 @@ func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager
        preBlockHash := preBlockHeader.Hash()
        nextBlockHeight := preBlockHeader.Height + 1
 
-       var xPrv chainkd.XPrv
-       if config.CommonConfig.Consensus.Dpos.XPrv == "" {
-               return nil, errors.New("Signer is empty")
-       }
-       xPrv.UnmarshalText([]byte(config.CommonConfig.Consensus.Dpos.XPrv))
-       xpub, _ := xPrv.XPub().MarshalText()
-
-       header := types.BlockHeader{
-               Version:           1,
-               Height:            nextBlockHeight,
-               PreviousBlockHash: preBlockHash,
-               Timestamp:         uint64(time.Now().Unix()),
-               BlockCommitment:   types.BlockCommitment{},
-               Coinbase:          xpub,
-               //Extra:             make([]byte, 32+65),
-       }
-
-       if err := engine.Prepare(c, &header); err != nil {
-               log.Error("Failed to prepare header for mining", "err", err)
-               return nil, err
+       b = &types.Block{
+               BlockHeader: types.BlockHeader{
+                       Version:           1,
+                       Height:            nextBlockHeight,
+                       PreviousBlockHash: preBlockHash,
+                       Timestamp:         uint64(time.Now().Unix()),
+                       BlockCommitment:   types.BlockCommitment{},
+               },
        }
-
-       b = &types.Block{}
        bcBlock := &bc.Block{BlockHeader: &bc.BlockHeader{Height: nextBlockHeight}}
        b.Transactions = []*types.Tx{nil}
 
@@ -129,6 +106,7 @@ func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager
                        blkGenSkipTxForErr(txPool, &tx.ID, err)
                        continue
                }
+
                gasStatus, err := validation.ValidateTx(tx, bcBlock)
                if err != nil {
                        if !gasStatus.GasValid {
@@ -155,20 +133,12 @@ func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager
                txEntries = append(txEntries, tx)
                gasUsed += uint64(gasStatus.GasUsed)
                txFee += txDesc.Fee
+
                if gasUsed == consensus.MaxBlockGas {
                        break
                }
        }
 
-       if txFee == 0 {
-               return nil, nil
-       }
-
-       if err := engine.Finalize(c, &header, txEntries[1:]); err != nil {
-               return nil, err
-       }
-
-       b.BlockHeader = header
        // creater coinbase transaction
        b.Transactions[0], err = createCoinbaseTx(accountManager, txFee, nextBlockHeight)
        if err != nil {
@@ -186,6 +156,6 @@ func NewBlockTemplate(c *protocol.Chain, txPool *protocol.TxPool, accountManager
 }
 
 func blkGenSkipTxForErr(txPool *protocol.TxPool, txHash *bc.Hash, err error) {
-       log.WithField("error", err).Error("mining block generation: skip tx due to")
+       log.WithFields(log.Fields{"module": logModule, "error": err}).Error("mining block generation: skip tx due to")
        txPool.RemoveTransaction(txHash)
 }