init finalizeTx

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

diff --git a/federation/warder.go b/federation/warder.go
index 0f66d4f..4e4c407 100644 (file)
--- a/federation/warder.go
+++ b/federation/warder.go
@@ -121,25 +121,31 @@ func (w *warder) processCrossTx(ormTx *orm.CrossTransaction) error {
                return err
        }
 
-       signs, err := w.getSigns(destTx, ormTx)
+       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
        }
 
-       w.attachSignsForTx(destTx, ormTx, w.position, signs)
+       // TODO: pass ref?
+       signersSigns = w.attachSignsForTx( /*destTx,*/ ormTx, w.position, signerSigns)
 
        for _, remote := range w.remotes {
-               signs, err := remote.RequestSigns(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")
@@ -278,32 +284,32 @@ func (w *warder) initDestTxSigns(destTx interface{}, ormTx *orm.CrossTransaction
                }).Error
 }
 
-func (w *warder) getSignData(destTx interface{}) ([]string, error) {
-       var signData []string
+func (w *warder) getSignData(destTx interface{}) ([][]byte, error) {
+       var signData [][]byte
 
        switch destTx := destTx.(type) {
        case *vaporTypes.Tx:
-               signData = make([]string, len(destTx.Inputs))
+               signData = make([][]byte, len(destTx.Inputs))
                for i := range destTx.Inputs {
                        signHash := destTx.SigHash(uint32(i))
-                       signData[i] = signHash.String()
+                       signData[i] = signHash.Bytes()
                }
 
        case *btmTypes.Tx:
-               signData = make([]string, len(destTx.Inputs))
+               signData = make([][]byte, len(destTx.Inputs))
                for i := range destTx.Inputs {
                        signHash := destTx.SigHash(uint32(i))
-                       signData[i] = signHash.String()
+                       signData[i] = signHash.Bytes()
                }
 
        default:
-               return []string{}, errUnknownTxType
+               return [][]byte{}, errUnknownTxType
        }
 
        return signData, nil
 }
 
-func (w *warder) getSigns(destTx interface{}, ormTx *orm.CrossTransaction) ([]string, error) {
+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")
        }
@@ -313,17 +319,14 @@ func (w *warder) getSigns(destTx interface{}, ormTx *orm.CrossTransaction) ([]st
                return nil, errors.New("getSignData")
        }
 
-       var signs []string
+       var signs [][]byte
        for _, data := range signData {
-               var sign []byte
+               var b [32]byte
+               copy(b[:], data)
                // vaporBc.Hash & btmBc.Hash are marshaled in the same way
-               msg := &vaporBc.Hash{}
-               if err := msg.UnmarshalText([]byte(data)); err != nil {
-                       return nil, errors.Wrap(err, "Unmarshal signData")
-               }
-
-               sign = w.xprv.Sign([]byte(msg.String()))
-               signs = append(signs, hex.EncodeToString(sign))
+               msg := vaporBc.NewHash(b)
+               sign := w.xprv.Sign([]byte(msg.String()))
+               signs = append(signs, sign)
        }
 
        return signs, nil
@@ -331,6 +334,19 @@ func (w *warder) getSigns(destTx interface{}, ormTx *orm.CrossTransaction) ([]st
 
 // TODO:
 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 {
@@ -357,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: