10 btmConsensus "github.com/bytom/consensus"
11 btmBc "github.com/bytom/protocol/bc"
12 "github.com/bytom/protocol/bc/types"
13 "github.com/bytom/protocol/vm"
14 "github.com/jinzhu/gorm"
15 log "github.com/sirupsen/logrus"
17 "github.com/vapor/consensus"
18 "github.com/vapor/errors"
19 "github.com/vapor/protocol/bc"
20 "github.com/vapor/toolbar/common/service"
21 "github.com/vapor/toolbar/federation/common"
22 "github.com/vapor/toolbar/federation/config"
23 "github.com/vapor/toolbar/federation/database"
24 "github.com/vapor/toolbar/federation/database/orm"
27 type mainchainKeeper struct {
31 assetStore *database.AssetStore
36 func NewMainchainKeeper(db *gorm.DB, assetStore *database.AssetStore, cfg *config.Config) *mainchainKeeper {
37 chain := &orm.Chain{Name: common.BytomChainName}
38 if err := db.Where(chain).First(chain).Error; err != nil {
39 log.WithField("err", err).Fatal("fail on get chain info")
42 return &mainchainKeeper{
45 node: service.NewNode(cfg.Mainchain.Upstream),
46 assetStore: assetStore,
47 federationProg: cfg.FederationProg,
52 func (m *mainchainKeeper) Run() {
53 ticker := time.NewTicker(time.Duration(m.cfg.SyncSeconds) * time.Second)
54 for ; true; <-ticker.C {
56 isUpdate, err := m.syncBlock()
58 log.WithField("error", err).Errorln("blockKeeper fail on process block")
69 func (m *mainchainKeeper) createCrossChainReqs(db *gorm.DB, crossTransactionID uint64, tx *types.Tx, statusFail bool) error {
70 prog := tx.Inputs[0].ControlProgram()
71 fromAddress := common.ProgToAddress(prog, &consensus.BytomMainNetParams)
72 toAddress := common.ProgToAddress(prog, &consensus.MainNetParams)
73 for i, rawOutput := range tx.Outputs {
74 if !bytes.Equal(rawOutput.OutputCommitment.ControlProgram, m.federationProg) {
78 if statusFail && *rawOutput.OutputCommitment.AssetAmount.AssetId != *btmConsensus.BTMAssetID {
82 asset, err := m.assetStore.GetByAssetID(rawOutput.OutputCommitment.AssetAmount.AssetId.String())
87 req := &orm.CrossTransactionReq{
88 CrossTransactionID: crossTransactionID,
91 AssetAmount: rawOutput.OutputCommitment.AssetAmount.Amount,
92 Script: hex.EncodeToString(prog),
93 FromAddress: fromAddress,
97 if err := db.Create(req).Error; err != nil {
104 func (m *mainchainKeeper) isDepositTx(tx *types.Tx) bool {
105 for _, input := range tx.Inputs {
106 if bytes.Equal(input.ControlProgram(), m.federationProg) {
111 for _, output := range tx.Outputs {
112 if bytes.Equal(output.OutputCommitment.ControlProgram, m.federationProg) {
119 func (m *mainchainKeeper) isWithdrawalTx(tx *types.Tx) bool {
120 for _, input := range tx.Inputs {
121 if !bytes.Equal(input.ControlProgram(), m.federationProg) {
126 if sourceTxHash := locateSideChainTx(tx.Outputs[len(tx.Outputs)-1]); sourceTxHash == "" {
132 func locateSideChainTx(output *types.TxOutput) string {
133 insts, err := vm.ParseProgram(output.OutputCommitment.ControlProgram)
142 return hex.EncodeToString(insts[1].Data)
145 func (m *mainchainKeeper) processBlock(db *gorm.DB, block *types.Block, txStatus *bc.TransactionStatus) error {
146 for i, tx := range block.Transactions {
147 if err := m.processIssuance(tx); err != nil {
151 if m.isDepositTx(tx) {
152 if err := m.processDepositTx(db, block, txStatus, i); err != nil {
157 if m.isWithdrawalTx(tx) {
158 if err := m.processWithdrawalTx(db, block, i); err != nil {
167 func (m *mainchainKeeper) processChainInfo(db *gorm.DB, block *types.Block) error {
168 blockHash := block.Hash()
169 res := db.Model(&orm.Chain{}).Where("block_hash = ?", block.PreviousBlockHash.String()).Updates(&orm.Chain{
170 BlockHash: blockHash.String(),
171 BlockHeight: block.Height,
173 if err := res.Error; err != nil {
177 if res.RowsAffected != 1 {
178 return ErrInconsistentDB
183 func (m *mainchainKeeper) processDepositTx(db *gorm.DB, block *types.Block, txStatus *bc.TransactionStatus, txIndex int) error {
184 tx := block.Transactions[txIndex]
186 switch res := tx.Entries[*tx.ResultIds[0]].(type) {
188 muxID = *res.Source.Ref
189 case *btmBc.Retirement:
190 muxID = *res.Source.Ref
195 rawTx, err := tx.MarshalText()
200 blockHash := block.Hash()
201 ormTx := &orm.CrossTransaction{
203 SourceBlockHeight: block.Height,
204 SourceBlockTimestamp: block.Timestamp,
205 SourceBlockHash: blockHash.String(),
206 SourceTxIndex: uint64(txIndex),
207 SourceMuxID: muxID.String(),
208 SourceTxHash: tx.ID.String(),
209 SourceRawTransaction: string(rawTx),
210 DestBlockHeight: sql.NullInt64{Valid: false},
211 DestBlockTimestamp: sql.NullInt64{Valid: false},
212 DestBlockHash: sql.NullString{Valid: false},
213 DestTxIndex: sql.NullInt64{Valid: false},
214 DestTxHash: sql.NullString{Valid: false},
215 Status: common.CrossTxPendingStatus,
217 if err := db.Create(ormTx).Error; err != nil {
218 return errors.Wrap(err, fmt.Sprintf("create mainchain DepositTx %s", tx.ID.String()))
221 return m.createCrossChainReqs(db, ormTx.ID, tx, txStatus.VerifyStatus[txIndex].StatusFail)
224 func (m *mainchainKeeper) processIssuance(tx *types.Tx) error {
225 for _, input := range tx.Inputs {
226 if input.InputType() != types.IssuanceInputType {
230 issuance := input.TypedInput.(*types.IssuanceInput)
231 assetID := issuance.AssetID()
232 if _, err := m.assetStore.GetByAssetID(assetID.String()); err == nil {
237 AssetID: assetID.String(),
238 IssuanceProgram: hex.EncodeToString(issuance.IssuanceProgram),
239 VMVersion: issuance.VMVersion,
240 Definition: string(issuance.AssetDefinition),
243 if err := m.db.Create(asset).Error; err != nil {
250 func (m *mainchainKeeper) processWithdrawalTx(db *gorm.DB, block *types.Block, txIndex int) error {
251 blockHash := block.Hash()
252 tx := block.Transactions[txIndex]
254 stmt := db.Model(&orm.CrossTransaction{}).Where(&orm.CrossTransaction{
255 SourceTxHash: locateSideChainTx(tx.Outputs[len(tx.Outputs)-1]),
256 Status: common.CrossTxPendingStatus,
257 }).UpdateColumn(&orm.CrossTransaction{
258 DestBlockHeight: sql.NullInt64{int64(block.Height), true},
259 DestBlockTimestamp: sql.NullInt64{int64(block.Timestamp), true},
260 DestBlockHash: sql.NullString{blockHash.String(), true},
261 DestTxIndex: sql.NullInt64{int64(txIndex), true},
262 DestTxHash: sql.NullString{tx.ID.String(), true},
263 Status: common.CrossTxCompletedStatus,
265 if stmt.Error != nil {
269 if stmt.RowsAffected != 1 {
270 return ErrInconsistentDB
275 func (m *mainchainKeeper) syncBlock() (bool, error) {
276 chain := &orm.Chain{ID: m.chainID}
277 if err := m.db.First(chain).Error; err != nil {
278 return false, errors.Wrap(err, "query chain")
281 height, err := m.node.GetBlockCount()
286 if height <= chain.BlockHeight+m.cfg.Confirmations {
290 nextBlockStr, txStatus, err := m.node.GetBlockByHeight(chain.BlockHeight + 1)
295 nextBlock := &types.Block{}
296 if err := nextBlock.UnmarshalText([]byte(nextBlockStr)); err != nil {
297 return false, errors.New("Unmarshal nextBlock")
300 if nextBlock.PreviousBlockHash.String() != chain.BlockHash {
301 log.WithFields(log.Fields{
302 "remote previous_block_Hash": nextBlock.PreviousBlockHash.String(),
303 "db block_hash": chain.BlockHash,
304 }).Fatal("fail on block hash mismatch")
307 if err := m.tryAttachBlock(nextBlock, txStatus); err != nil {
314 func (m *mainchainKeeper) tryAttachBlock(block *types.Block, txStatus *bc.TransactionStatus) error {
315 blockHash := block.Hash()
316 log.WithFields(log.Fields{"block_height": block.Height, "block_hash": blockHash.String()}).Info("start to attachBlock")
319 if err := m.processBlock(dbTx, block, txStatus); err != nil {
324 if err := m.processChainInfo(dbTx, block); err != nil {
329 return dbTx.Commit().Error