Implemented chaining txs

Author: pavel.soloviev

src/service/claim.go

@@ -59,12 +59,7 @@ func (r *RelayerSRV) sendClaim(worker workers.IWorker, swap *storage.Swap) (stri
 		return "", fmt.Errorf("could not send claim tx: %s", err)
 	}
 
-	resID := swap.ResourceID
-	if swap.DestinationChainID == r.laWorker.GetDestinationID() {
-		_, resID = utils.GetGasSwapResourceIDs(swap.ResourceID)
-	} else {
-		resID, _ = utils.GetGasSwapResourceIDs(swap.ResourceID)
-	}
+	resID := utils.GetCurrentStep(swap.ResourceID, swap.StepIndex)
 	originDecimals, err := originWorker.GetDecimalsFromResourceID(resID)
 	if err != nil {
 		println("error in decimals", err.Error())
@@ -99,7 +94,7 @@ func (r *RelayerSRV) sendClaim(worker workers.IWorker, swap *storage.Swap) (stri
 		swap.DepositNonce, swap.SenderAddr, amount, swap.ResourceID)
 
 	txHash, nonce, err := worker.Vote(swap.DepositNonce, utils.StringToBytes8(swap.OriginChainID), utils.StringToBytes8(swap.DestinationChainID),
-		utils.StringToBytes32(swap.ResourceID), swap.ReceiverAddr, amount)
+		utils.StringToBytes32(swap.ResourceID), swap.StepIndex, swap.ReceiverAddr, amount)
 	if err != nil {
 		txSent.ErrMsg = err.Error()
 		txSent.Status = storage.TxSentStatusNotFound

src/service/relayer.go

@@ -152,6 +152,7 @@ func (r *RelayerSRV) ConfirmWorkerTx(worker workers.IWorker) {
 					InTokenAddr:        txLog.InTokenAddr,
 					DepositNonce:       txLog.DepositNonce,
 					ResourceID:         txLog.ResourceID,
+					StepIndex:          txLog.StepIndex,
 					OutAmount:          txLog.OutAmount,
 					DestinationChainID: txLog.DestinationChainID,
 					OriginChainID:      txLog.OriginСhainID,

src/service/storage/models.go

@@ -32,6 +32,7 @@ type TxLog struct {
 	DestinationChainID string      `gorm:"type:TEXT"`
 	DepositNonce       uint64      `gorm:"type:BIGINT"`
 	ResourceID         string      `gorm:"type:TEXT"`
+	StepIndex          uint8       `gorm:"type:UINT"`
 	SwapStatus         SwapStatus  `gorm:"type:TEXT"`
 	ExpireHeight       int64       `gorm:"type:BIGINT"`
 	Timestamp          int64       `gorm:"type:BIGINT"`
@@ -59,6 +60,7 @@ type Swap struct {
 	RelayerOutAmount string
 	DepositNonce     uint64
 	ResourceID       string
+	StepIndex        uint8
 	// ExpireHeight     int64
 	Height int64
 	//	Timestamp  int64

src/service/storage/swap.go

@@ -55,18 +55,6 @@ func (d *DataBase) GetSwapByTxHash(txHash string) (*Swap, error) {
 	return swap, nil
 }
 
-// GetSwapByTxHash ...
-func (d *DataBase) GetSwapByTxHash(txHash string) (*Swap, error) {
-	swap := &Swap{}
-	if err := d.db.Where("tx_hash = ? and status in (?)", txHash,
-		[]SwapStatus{SwapStatusDepositConfirmed, SwapStatusClaimSent, SwapStatusClaimConfirmed, SwapStatusClaimSentFailed, SwapStatusDepositFailed, SwapStatusPassedConfirmed, SwapStatusPassedSent, SwapStatusSpendSent, SwapStatusSpendConfirmed, SwapStatusRejected}).
-		Find(&swap).Error; err != nil {
-		return nil, err
-	}
-
-	return swap, nil
-}
-
 // UpdateSwapStatus ...
 func (d *DataBase) UpdateSwapStatus(swap *Swap, status SwapStatus, rOutAmount string) {
 	swap.Status = status

src/service/workers/eth-compatible/abi/bridge/la/Bridge.go

@@ -223,7 +223,7 @@ func (w *Erc20Worker) GetHeight() (int64, error) {
 }
 
 // Vote ...
-func (w *Erc20Worker) Vote(depositNonce uint64, originchainID [8]byte, destinationChainID [8]byte, resourceID [32]byte, receiptAddr string, amount string) (string, string, error) {
+func (w *Erc20Worker) Vote(depositNonce uint64, originchainID [8]byte, destinationChainID [8]byte, resourceID [32]byte, stepIndex uint8, receiptAddr string, amount string) (string, string, error) {
 	auth, err := w.getTransactor()
 	if err != nil {
 		return "", "", err
@@ -235,7 +235,7 @@ func (w *Erc20Worker) Vote(depositNonce uint64, originchainID [8]byte, destinati
 	}
 
 	value, _ := new(big.Int).SetString(amount, 10)
-	tx, err := instance.VoteProposal(auth, originchainID, destinationChainID, depositNonce, resourceID, common.HexToAddress(receiptAddr), value)
+	tx, err := instance.VoteProposal(auth, originchainID, destinationChainID, depositNonce, resourceID, common.HexToAddress(receiptAddr), value, []byte{stepIndex})
 	if err != nil {
 		return "", "", err
 	}

src/service/workers/eth-compatible/abi/handler/eth/Handler.go

@@ -72,6 +72,7 @@ func (ev DepositEvent) ToTxLog() *storage.TxLog {
 		OriginСhainID:      common.Bytes2Hex(ev.OriginChainID[:]),
 		SwapID:             utils.CalcutateSwapID(common.Bytes2Hex(ev.OriginChainID[:]), common.Bytes2Hex(ev.DestinationChainID[:]), fmt.Sprint(ev.DepositNonce)),
 		ResourceID:         common.Bytes2Hex(ev.ResourceID[:]),
+		StepIndex:          ev.Params[0],
 		DepositNonce:       ev.DepositNonce,
 		SenderAddr:         ev.Depositor.Hex(),
 		ReceiverAddr:       ev.RecipientAddress.Hex(),

src/service/workers/eth-compatible/abi/handler/la/Handler.go

@@ -2,7 +2,6 @@ package utils
 
 import (
 	"crypto/ecdsa"
-	"encoding/hex"
 	"math"
 	"math/big"
 
@@ -85,13 +84,6 @@ func ConvertDecimals(originDecimals, destDecimals uint8, amount string) string {
 	return new(big.Int).Quo(new(big.Int).Mul(amountInFloat, dest), origin).String()
 }
 
-func GetGasSwapResourceIDs(resourceID string) (destResourceID, originResourceID string) {
-	swapIdentifier := hex.EncodeToString([]byte("swap"))
-	if resourceID[:8] == swapIdentifier {
-		originResourceID = "00000000000000000000000000000000000000000000" + resourceID[44:]
-		destResourceID = "00000000000000000000000000000000000000000000" + resourceID[24:44]
-		return destResourceID, originResourceID
-	} else {
-		return resourceID, resourceID
-	}
+func GetCurrentStep(resourceID string, stepIndex uint8) string {
+	return resourceID[16*stepIndex:16*stepIndex+8] + "00000000000000000000000000000000000000000000000000000000"
 }