9 "github.com/jinzhu/gorm"
10 log "github.com/sirupsen/logrus"
12 "github.com/bytom/vapor/consensus"
13 "github.com/bytom/vapor/errors"
14 "github.com/bytom/vapor/protocol/bc"
15 "github.com/bytom/vapor/protocol/bc/types"
16 "github.com/bytom/vapor/toolbar/federation/common"
17 "github.com/bytom/vapor/toolbar/federation/config"
18 "github.com/bytom/vapor/toolbar/federation/database"
19 "github.com/bytom/vapor/toolbar/federation/database/orm"
20 "github.com/bytom/vapor/toolbar/federation/service"
23 type sidechainKeeper struct {
27 assetStore *database.AssetStore
29 netParams consensus.Params
32 func NewSidechainKeeper(db *gorm.DB, assetStore *database.AssetStore, cfg *config.Config) *sidechainKeeper {
33 chain := &orm.Chain{Name: common.VaporChainName}
34 if err := db.Where(chain).First(chain).Error; err != nil {
35 log.WithField("err", err).Fatal("fail on get chain info")
38 return &sidechainKeeper{
41 node: service.NewNode(cfg.Sidechain.Upstream),
42 assetStore: assetStore,
44 netParams: consensus.NetParams[cfg.Network],
48 func (s *sidechainKeeper) Run() {
49 ticker := time.NewTicker(time.Duration(s.cfg.SyncSeconds) * time.Second)
50 for ; true; <-ticker.C {
52 isUpdate, err := s.syncBlock()
54 log.WithField("error", err).Errorln("blockKeeper fail on process block")
65 func (s *sidechainKeeper) createCrossChainReqs(db *gorm.DB, crossTransactionID uint64, tx *types.Tx, statusFail bool) error {
66 fromAddress := common.ProgToAddress(tx.Inputs[0].ControlProgram(), &s.netParams)
67 for i, rawOutput := range tx.Outputs {
68 if rawOutput.OutputType() != types.CrossChainOutputType {
72 if statusFail && *rawOutput.OutputCommitment().AssetAmount.AssetId != *consensus.BTMAssetID {
76 asset, err := s.assetStore.GetByAssetID(rawOutput.OutputCommitment().AssetAmount.AssetId.String())
81 if asset.IsOpenFederationIssue {
85 prog := rawOutput.ControlProgram()
86 req := &orm.CrossTransactionReq{
87 CrossTransactionID: crossTransactionID,
90 AssetAmount: rawOutput.OutputCommitment().AssetAmount.Amount,
91 Script: hex.EncodeToString(prog),
92 FromAddress: fromAddress,
93 ToAddress: common.ProgToAddress(prog, consensus.BytomMainNetParams(&s.netParams)),
96 if err := db.Create(req).Error; err != nil {
103 func (s *sidechainKeeper) isDepositTx(tx *types.Tx) (bool, error) {
104 for _, input := range tx.Inputs {
105 if input.InputType() != types.CrossChainInputType {
109 if isOFAsset, err := s.isOpenFederationAsset(input.AssetAmount().AssetId); err != nil {
111 } else if !isOFAsset {
118 func (s *sidechainKeeper) isWithdrawalTx(tx *types.Tx) (bool, error) {
119 for _, output := range tx.Outputs {
120 if output.OutputType() != types.CrossChainOutputType {
124 if isOFAsset, err := s.isOpenFederationAsset(output.AssetAmount().AssetId); err != nil {
126 } else if !isOFAsset {
133 func (s *sidechainKeeper) processBlock(db *gorm.DB, block *types.Block, txStatus *bc.TransactionStatus) error {
134 for i, tx := range block.Transactions {
135 if isDeposit, err := s.isDepositTx(tx); err != nil {
137 } else if isDeposit {
138 if err := s.processDepositTx(db, block, i); err != nil {
143 if isWithdrawal, err := s.isWithdrawalTx(tx); err != nil {
145 } else if isWithdrawal {
146 if err := s.processWithdrawalTx(db, block, txStatus, i); err != nil {
154 func (s *sidechainKeeper) processChainInfo(db *gorm.DB, block *types.Block) error {
155 blockHash := block.Hash()
156 res := db.Model(&orm.Chain{}).Where("block_hash = ?", block.PreviousBlockHash.String()).Updates(&orm.Chain{
157 BlockHash: blockHash.String(),
158 BlockHeight: block.Height,
160 if err := res.Error; err != nil {
164 if res.RowsAffected != 1 {
165 return ErrInconsistentDB
171 func (s *sidechainKeeper) processDepositTx(db *gorm.DB, block *types.Block, txIndex int) error {
172 tx := block.Transactions[txIndex]
173 sourceTxHash, err := s.locateMainChainTx(tx.Inputs[0])
178 blockHash := block.Hash()
179 stmt := db.Model(&orm.CrossTransaction{}).Where(&orm.CrossTransaction{
180 SourceTxHash: sourceTxHash,
181 Status: common.CrossTxPendingStatus,
182 }).UpdateColumn(&orm.CrossTransaction{
183 DestBlockHeight: sql.NullInt64{int64(block.Height), true},
184 DestBlockTimestamp: sql.NullInt64{int64(block.Timestamp / 1000), true},
185 DestBlockHash: sql.NullString{blockHash.String(), true},
186 DestTxIndex: sql.NullInt64{int64(txIndex), true},
187 DestTxHash: sql.NullString{tx.ID.String(), true},
188 Status: common.CrossTxCompletedStatus,
190 if stmt.Error != nil {
194 if stmt.RowsAffected != 1 {
195 return errors.Wrap(ErrInconsistentDB, "fail on find deposit data on database")
200 func (s *sidechainKeeper) isOpenFederationAsset(assetID *bc.AssetID) (bool, error) {
201 asset, err := s.assetStore.GetByAssetID(assetID.String())
206 return asset.IsOpenFederationIssue, nil
209 func (s *sidechainKeeper) processWithdrawalTx(db *gorm.DB, block *types.Block, txStatus *bc.TransactionStatus, txIndex int) error {
210 tx := block.Transactions[txIndex]
212 switch res := tx.Entries[*tx.ResultIds[0]].(type) {
213 case *bc.CrossChainOutput:
214 muxID = *res.Source.Ref
215 case *bc.IntraChainOutput:
216 muxID = *res.Source.Ref
218 muxID = *res.Source.Ref
220 muxID = *res.Source.Ref
225 rawTx, err := tx.MarshalText()
230 blockHash := block.Hash()
231 ormTx := &orm.CrossTransaction{
233 SourceBlockHeight: block.Height,
234 SourceBlockTimestamp: block.Timestamp / 1000,
235 SourceBlockHash: blockHash.String(),
236 SourceTxIndex: uint64(txIndex),
237 SourceMuxID: muxID.String(),
238 SourceTxHash: tx.ID.String(),
239 SourceRawTransaction: string(rawTx),
240 DestBlockHeight: sql.NullInt64{Valid: false},
241 DestBlockTimestamp: sql.NullInt64{Valid: false},
242 DestBlockHash: sql.NullString{Valid: false},
243 DestTxIndex: sql.NullInt64{Valid: false},
244 DestTxHash: sql.NullString{Valid: false},
245 Status: common.CrossTxPendingStatus,
247 if err := db.Create(ormTx).Error; err != nil {
248 return errors.Wrap(err, fmt.Sprintf("create sidechain WithdrawalTx %s", tx.ID.String()))
251 return s.createCrossChainReqs(db, ormTx.ID, tx, txStatus.VerifyStatus[txIndex].StatusFail)
254 func (s *sidechainKeeper) locateMainChainTx(input *types.TxInput) (string, error) {
255 if input.InputType() != types.CrossChainInputType {
256 return "", errors.New("found weird crossChain tx")
259 crossIn := input.TypedInput.(*types.CrossChainInput)
260 crossTx := &orm.CrossTransaction{SourceMuxID: crossIn.SpendCommitment.SourceID.String()}
261 if err := s.db.Where(crossTx).First(crossTx).Error; err != nil {
262 return "", errors.Wrap(err, "fail on find CrossTransaction")
264 return crossTx.SourceTxHash, nil
267 func (s *sidechainKeeper) syncBlock() (bool, error) {
268 chain := &orm.Chain{ID: s.chainID}
269 if err := s.db.First(chain).Error; err != nil {
270 return false, errors.Wrap(err, "query chain")
273 height, err := s.node.GetBlockCount()
278 if height <= chain.BlockHeight+s.cfg.Confirmations {
282 nextBlockStr, txStatus, err := s.node.GetBlockByHeight(chain.BlockHeight + 1)
287 nextBlock := &types.Block{}
288 if err := nextBlock.UnmarshalText([]byte(nextBlockStr)); err != nil {
289 return false, errors.New("Unmarshal nextBlock")
292 if nextBlock.PreviousBlockHash.String() != chain.BlockHash {
293 log.WithFields(log.Fields{
294 "remote previous_block_Hash": nextBlock.PreviousBlockHash.String(),
295 "db block_hash": chain.BlockHash,
296 }).Fatal("fail on block hash mismatch")
299 if err := s.tryAttachBlock(nextBlock, txStatus); err != nil {
306 func (s *sidechainKeeper) tryAttachBlock(block *types.Block, txStatus *bc.TransactionStatus) error {
307 blockHash := block.Hash()
308 log.WithFields(log.Fields{"block_height": block.Height, "block_hash": blockHash.String()}).Info("start to attachBlock")
311 if err := s.processBlock(dbTx, block, txStatus); err != nil {
316 if err := s.processChainInfo(dbTx, block); err != nil {
320 return dbTx.Commit().Error