init finalizeTx

[bytom/vapor.git] / federation / warder.go

diff --git a/federation/warder.go b/federation/warder.go
index e3d03b9..4e4c407 100644 (file)
--- a/federation/warder.go
+++ b/federation/warder.go
@@ -3,6 +3,7 @@ package federation
 import (
        "database/sql"
        "encoding/hex"
+       "encoding/json"
        "time"
 
        btmTypes "github.com/bytom/protocol/bc/types"
@@ -23,6 +24,8 @@ import (
 
 var collectInterval = 5 * time.Second
 
+var errUnknownTxType = errors.New("unknown tx type")
+
 type warder struct {
        db            *gorm.DB
        assetStore    *database.AssetStore
@@ -118,22 +121,31 @@ func (w *warder) processCrossTx(ormTx *orm.CrossTransaction) error {
                return err
        }
 
-       if err := w.signDestTx(destTx, ormTx); err != nil {
-               log.WithFields(log.Fields{"err": err, "cross-chain tx": ormTx}).Warnln("signDestTx")
+       var signersSigns [][][]byte
+
+       signerSigns, err := w.getSigns(destTx, ormTx)
+       if err != nil {
+               log.WithFields(log.Fields{"err": err, "cross-chain tx": ormTx}).Warnln("getSigns")
                return err
        }
 
+       // TODO: pass ref?
+       signersSigns = w.attachSignsForTx( /*destTx,*/ ormTx, w.position, signerSigns)
+
        for _, remote := range w.remotes {
-               signs, err := remote.RequestSign(destTx, ormTx)
+               signerSigns, err := remote.RequestSigns(destTx, ormTx)
                if err != nil {
                        log.WithFields(log.Fields{"err": err, "remote": remote, "cross-chain tx": ormTx}).Warnln("RequestSign")
                        return err
                }
 
-               w.attachSignsForTx(destTx, ormTx, remote.Position, signs)
+               // TODO: pass ref?
+               signersSigns = w.attachSignsForTx( /*destTx,*/ ormTx, remote.Position, signerSigns)
        }
 
-       if w.isTxSignsReachQuorum(destTx) && w.isLeader() {
+       if w.isTxSignsReachQuorum(signersSigns) && w.isLeader() {
+               // TODO: check err
+               w.finalizeTx(destTx, signersSigns)
                submittedTxID, err := w.submitTx(destTx)
                if err != nil {
                        log.WithFields(log.Fields{"err": err, "cross-chain tx": ormTx, "dest tx": destTx}).Warnln("submitTx")
@@ -272,17 +284,84 @@ func (w *warder) initDestTxSigns(destTx interface{}, ormTx *orm.CrossTransaction
                }).Error
 }
 
-// TODO:
-func (w *warder) signDestTx(destTx interface{}, tx *orm.CrossTransaction) error {
-       if tx.Status != common.CrossTxPendingStatus || !tx.DestTxHash.Valid {
-               return errors.New("cross-chain tx status error")
+func (w *warder) getSignData(destTx interface{}) ([][]byte, error) {
+       var signData [][]byte
+
+       switch destTx := destTx.(type) {
+       case *vaporTypes.Tx:
+               signData = make([][]byte, len(destTx.Inputs))
+               for i := range destTx.Inputs {
+                       signHash := destTx.SigHash(uint32(i))
+                       signData[i] = signHash.Bytes()
+               }
+
+       case *btmTypes.Tx:
+               signData = make([][]byte, len(destTx.Inputs))
+               for i := range destTx.Inputs {
+                       signHash := destTx.SigHash(uint32(i))
+                       signData[i] = signHash.Bytes()
+               }
+
+       default:
+               return [][]byte{}, errUnknownTxType
        }
 
-       return nil
+       return signData, nil
+}
+
+func (w *warder) getSigns(destTx interface{}, ormTx *orm.CrossTransaction) ([][]byte, error) {
+       if ormTx.Status != common.CrossTxPendingStatus || !ormTx.DestTxHash.Valid {
+               return nil, errors.New("cross-chain tx status error")
+       }
+
+       signData, err := w.getSignData(destTx)
+       if err != nil {
+               return nil, errors.New("getSignData")
+       }
+
+       var signs [][]byte
+       for _, data := range signData {
+               var b [32]byte
+               copy(b[:], data)
+               // vaporBc.Hash & btmBc.Hash are marshaled in the same way
+               msg := vaporBc.NewHash(b)
+               sign := w.xprv.Sign([]byte(msg.String()))
+               signs = append(signs, sign)
+       }
+
+       return signs, nil
 }
 
 // TODO:
-func (w *warder) attachSignsForTx(destTx interface{}, ormTx *orm.CrossTransaction, position uint8, signs string) {
+func (w *warder) attachSignsForTx(destTx interface{}, ormTx *orm.CrossTransaction, position uint8, signs []string) error {
+       var inputsLen int
+       switch destTx := destTx.(type) {
+       case *vaporTypes.Tx:
+               inputsLen = len(destTx.Inputs)
+       case *btmTypes.Tx:
+               inputsLen = len(destTx.Inputs)
+       default:
+               return errUnknownTxType
+       }
+
+       // finalize tx?
+
+       signWitness := make([][]string, inputsLen)
+
+       b, err := json.Marshal(signs)
+       if err != nil {
+               return errors.Wrap(err, "marshal signs")
+       }
+
+       return w.db.Model(&orm.CrossTransactionSign{}).
+               Where(&orm.CrossTransactionSign{
+                       CrossTransactionID: ormTx.ID,
+                       WarderID:           w.position,
+               }).
+               UpdateColumn(&orm.CrossTransactionSign{
+                       Signatures: string(b),
+                       Status:     common.CrossTxSignCompletedStatus,
+               }).Error
 }
 
 // TODO:
@@ -294,6 +373,10 @@ func (w *warder) isLeader() bool {
        return w.position == 1
 }
 
+func (w *warder) finalizeTx(destTx interface{}, signersSigns [][][]byte) error {
+       return nil
+}
+
 func (w *warder) submitTx(destTx interface{}) (string, error) {
        switch tx := destTx.(type) {
        case *btmTypes.Tx:
@@ -301,7 +384,7 @@ func (w *warder) submitTx(destTx interface{}) (string, error) {
        case *vaporTypes.Tx:
                return w.sidechainNode.SubmitTx(tx)
        default:
-               return "", errors.New("unknown destTx type")
+               return "", errUnknownTxType
        }
 }