Feat/native esdts bridging

bridges/ethMultiversX/bridgeExecutor.go

@@ -4,12 +4,14 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"math/big"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/multiversx/mx-bridge-eth-go/clients"
 	"github.com/multiversx/mx-bridge-eth-go/clients/ethereum/contract"
 	"github.com/multiversx/mx-bridge-eth-go/core"
+	"github.com/multiversx/mx-bridge-eth-go/core/batchProcessor"
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	logger "github.com/multiversx/mx-chain-logger-go"
 )
@@ -182,7 +184,7 @@ func (executor *bridgeExecutor) GetLastExecutedEthBatchIDFromMultiversX(ctx cont
 	return batchID, err
 }
 
-// VerifyLastDepositNonceExecutedOnEthereumBatch will check the deposit nonces from the fetched batch from Ethereum client
+// VerifyLastDepositNonceExecutedOnEthereumBatch will check the deposit Nonces from the fetched batch from Ethereum client
 func (executor *bridgeExecutor) VerifyLastDepositNonceExecutedOnEthereumBatch(ctx context.Context) error {
 	if executor.batch == nil {
 		return ErrNilBatch
@@ -524,7 +526,8 @@ func (executor *bridgeExecutor) SignTransferOnEthereum() error {
 		return ErrNilBatch
 	}
 
-	hash, err := executor.ethereumClient.GenerateMessageHash(executor.batch)
+	argLists := batchProcessor.ExtractListMvxToEth(executor.batch)
+	hash, err := executor.ethereumClient.GenerateMessageHash(argLists, executor.batch.ID)
 	if err != nil {
 		return err
 	}
@@ -550,7 +553,11 @@ func (executor *bridgeExecutor) PerformTransferOnEthereum(ctx context.Context) e
 
 	executor.log.Debug("fetched quorum size", "quorum", quorumSize.Int64())
 
-	hash, err := executor.ethereumClient.ExecuteTransfer(ctx, executor.msgHash, executor.batch, int(quorumSize.Int64()))
+	argLists := batchProcessor.ExtractListMvxToEth(executor.batch)
+
+	executor.log.Info("executing transfer " + executor.batch.String())
+
+	hash, err := executor.ethereumClient.ExecuteTransfer(ctx, executor.msgHash, argLists, executor.batch.ID, int(quorumSize.Int64()))
 	if err != nil {
 		return err
 	}
@@ -561,6 +568,111 @@ func (executor *bridgeExecutor) PerformTransferOnEthereum(ctx context.Context) e
 	return nil
 }
 
+func (executor *bridgeExecutor) checkCumulatedTransfers(ctx context.Context, tokens []common.Address, convertedTokens [][]byte, amounts []*big.Int) error {
+	for i, token := range tokens {
+		err := executor.checkToken(ctx, token, convertedTokens[i], amounts[i])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (executor *bridgeExecutor) checkToken(ctx context.Context, token common.Address, convertedToken []byte, amount *big.Int) error {
+	isMintBurnToken, err := executor.isMintBurnToken(ctx, token, convertedToken)
+	if err != nil {
+		return err
+	}
+
+	if isMintBurnToken {
+		return executor.checkRequiredMintBurnBalance(ctx, token, convertedToken)
+	}
+
+	return executor.ethereumClient.CheckRequiredBalance(ctx, token, amount)
+}
+
+func (executor *bridgeExecutor) isMintBurnToken(ctx context.Context, token common.Address, convertedToken []byte) (bool, error) {
+	isMintBurnOnEthereum := executor.isMintBurnOnEthereum(ctx, token)
+	isMintBurnOnMultiversX := executor.isMintBurnOnMultiversX(ctx, convertedToken)
+	if isMintBurnOnEthereum != isMintBurnOnMultiversX {
+		return false, fmt.Errorf("%w isMintBurnOnEthereum = %v, isMintBurnOnMultiversX = %v", ErrInvalidSetupMintBurnToken, isMintBurnOnEthereum, isMintBurnOnMultiversX)
+	}
+	return isMintBurnOnEthereum, nil
+}
+
+func (executor *bridgeExecutor) checkRequiredMintBurnBalance(ctx context.Context, ethToken common.Address, mvxToken []byte) error {
+	ethBalance, err := executor.ethereumClient.TokenMintedBalances(ctx, ethToken)
+	if err != nil {
+		return err
+	}
+
+	mvxBalance, err := executor.multiversXClient.AccumulatedBurnedTokens(ctx, mvxToken)
+	if err != nil {
+		return err
+	}
+	if ethBalance.Cmp(mvxBalance) > 0 {
+		return fmt.Errorf("%w, balance for ERC20 token %s is %s and the balance for ESDT token %s is %s",
+			ErrMintBurnBalance, ethToken.String(), ethBalance.String(), mvxToken, mvxBalance.String())
+	}
+
+	executor.log.Debug("bridgeExecutor.checkRequiredMintBurnBalance",
+		"ERC20 token", ethToken.String(),
+		"ERC20 native balance", ethBalance.String(),
+		"ESDT token", mvxToken,
+		"ESDT native balance", mvxBalance.String(),
+	)
+
+	return nil
+}
+
+func (executor *bridgeExecutor) isMintBurnOnEthereum(ctx context.Context, erc20Address common.Address) bool {
+	isMintBurn, err := executor.ethereumClient.WhitelistedTokensMintBurn(ctx, erc20Address)
+	if err != nil {
+		return false
+	}
+	return isMintBurn
+}
+
+func (executor *bridgeExecutor) isMintBurnOnMultiversX(ctx context.Context, token []byte) bool {
+	isMintBurn, err := executor.multiversXClient.IsMintBurnAllowed(ctx, token)
+	if err != nil {
+		return false
+	}
+	return isMintBurn
+}
+
+// CheckAvailableTokens checks the available balances handling also the native tokens
+func (executor *bridgeExecutor) CheckAvailableTokens(ctx context.Context, ethTokens []common.Address, mvxTokens [][]byte, amounts []*big.Int) error {
+	ethTokens, mvxTokens, amounts = executor.getCumulatedTransfers(ethTokens, mvxTokens, amounts)
+
+	return executor.checkCumulatedTransfers(ctx, ethTokens, mvxTokens, amounts)
+}
+
+func (executor *bridgeExecutor) getCumulatedTransfers(ethTokens []common.Address, mvxTokens [][]byte, amounts []*big.Int) ([]common.Address, [][]byte, []*big.Int) {
+	cumulatedAmounts := make(map[common.Address]*big.Int)
+	uniqueTokens := make([]common.Address, 0)
+	uniqueConvertedTokens := make([][]byte, 0)
+
+	for i, token := range ethTokens {
+		existingValue, exists := cumulatedAmounts[token]
+		if exists {
+			existingValue.Add(existingValue, amounts[i])
+			continue
+		}
+
+		cumulatedAmounts[token] = amounts[i]
+		uniqueTokens = append(uniqueTokens, token)
+		uniqueConvertedTokens = append(uniqueConvertedTokens, mvxTokens[i])
+	}
+
+	finalAmounts := make([]*big.Int, len(uniqueTokens))
+	for i, token := range uniqueTokens {
+		finalAmounts[i] = cumulatedAmounts[token]
+	}
+
+	return uniqueTokens, uniqueConvertedTokens, finalAmounts
+}
+
 // ProcessQuorumReachedOnEthereum returns true if the proposed transfer reached the set quorum
 func (executor *bridgeExecutor) ProcessQuorumReachedOnEthereum(ctx context.Context) (bool, error) {
 	return executor.ethereumClient.IsQuorumReached(ctx, executor.msgHash)

bridges/ethMultiversX/bridgeExecutor_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/multiversx/mx-bridge-eth-go/clients"
 	"github.com/multiversx/mx-bridge-eth-go/clients/ethereum/contract"
 	"github.com/multiversx/mx-bridge-eth-go/core"
+	"github.com/multiversx/mx-bridge-eth-go/core/batchProcessor"
 	"github.com/multiversx/mx-bridge-eth-go/testsCommon"
 	bridgeTests "github.com/multiversx/mx-bridge-eth-go/testsCommon/bridge"
 	"github.com/multiversx/mx-chain-core-go/core/check"
@@ -1154,7 +1155,7 @@ func TestMultiversXToEthBridgeExecutor_SignTransferOnEthereum(t *testing.T) {
 
 		args := createMockExecutorArgs()
 		args.EthereumClient = &bridgeTests.EthereumClientStub{
-			GenerateMessageHashCalled: func(batch *clients.TransferBatch) (common.Hash, error) {
+			GenerateMessageHashCalled: func(batch *batchProcessor.ArgListsBatch, batchID uint64) (common.Hash, error) {
 				return common.Hash{}, expectedErr
 			},
 		}
@@ -1171,7 +1172,7 @@ func TestMultiversXToEthBridgeExecutor_SignTransferOnEthereum(t *testing.T) {
 		wasCalledBroadcastSignatureForMessageHashCalled := false
 		args := createMockExecutorArgs()
 		args.EthereumClient = &bridgeTests.EthereumClientStub{
-			GenerateMessageHashCalled: func(batch *clients.TransferBatch) (common.Hash, error) {
+			GenerateMessageHashCalled: func(batch *batchProcessor.ArgListsBatch, batchID uint64) (common.Hash, error) {
 				wasCalledGenerateMessageHashCalled = true
 				return common.Hash{}, nil
 			},
@@ -1224,7 +1225,7 @@ func TestMultiversXToEthBridgeExecutor_PerformTransferOnEthereum(t *testing.T) {
 			GetQuorumSizeCalled: func(ctx context.Context) (*big.Int, error) {
 				return big.NewInt(0), nil
 			},
-			ExecuteTransferCalled: func(ctx context.Context, msgHash common.Hash, batch *clients.TransferBatch, quorum int) (string, error) {
+			ExecuteTransferCalled: func(ctx context.Context, msgHash common.Hash, batch *batchProcessor.ArgListsBatch, batchId uint64, quorum int) (string, error) {
 				return "", expectedErr
 			},
 		}
@@ -1247,9 +1248,16 @@ func TestMultiversXToEthBridgeExecutor_PerformTransferOnEthereum(t *testing.T) {
 				wasCalledGetQuorumSizeCalled = true
 				return big.NewInt(int64(providedQuorum)), nil
 			},
-			ExecuteTransferCalled: func(ctx context.Context, msgHash common.Hash, batch *clients.TransferBatch, quorum int) (string, error) {
+			ExecuteTransferCalled: func(ctx context.Context, msgHash common.Hash, batch *batchProcessor.ArgListsBatch, batchId uint64, quorum int) (string, error) {
 				assert.True(t, providedHash == msgHash)
-				assert.True(t, providedBatch == batch)
+				assert.True(t, providedBatch.ID == batchId)
+				for i := 0; i < len(providedBatch.Deposits); i++ {
+					assert.Equal(t, providedBatch.Deposits[i].Amount, batch.Amounts[i])
+					assert.Equal(t, providedBatch.Deposits[i].Nonce, batch.Nonces[i].Uint64())
+					assert.Equal(t, providedBatch.Deposits[i].ToBytes, batch.Recipients[i].Bytes())
+					assert.Equal(t, providedBatch.Deposits[i].SourceTokenBytes, batch.EthTokens[i].Bytes())
+					assert.Equal(t, providedBatch.Deposits[i].DestinationTokenBytes, batch.MvxTokenBytes[i])
+				}
 				assert.True(t, providedQuorum == quorum)
 
 				wasCalledExecuteTransferCalled = true
@@ -1726,3 +1734,134 @@ func TestBridgeExecutor_ValidateBatch(t *testing.T) {
 	assert.True(t, result)
 	assert.True(t, validateBatchCalled)
 }
+
+func TestBridgeExecutor_CheckAvailableTokens(t *testing.T) {
+	t.Parallel()
+
+	t.Run("wrong balances should error", func(t *testing.T) {
+		args := createMockExecutorArgs()
+		tokenMintedBalancesCalled := false
+		args.EthereumClient = &bridgeTests.EthereumClientStub{
+			WhitelistedTokensMintBurnCalled: func(ctx context.Context, token common.Address) (bool, error) {
+				return true, nil
+			},
+			TokenMintedBalancesCalled: func(ctx context.Context, token common.Address) (*big.Int, error) {
+				tokenMintedBalancesCalled = true
+
+				return big.NewInt(3701), nil // eth holds a higher balance than the mvx
+			},
+		}
+
+		accumulatedBurnedTokensCalled := false
+		args.MultiversXClient = &bridgeTests.MultiversXClientStub{
+			IsMintBurnAllowedCalled: func(ctx context.Context, token []byte) (bool, error) {
+				return true, nil
+			},
+			AccumulatedBurnedTokensCalled: func(ctx context.Context, token []byte) (*big.Int, error) {
+				accumulatedBurnedTokensCalled = true
+				return big.NewInt(3700), nil
+			},
+		}
+
+		executor, _ := NewBridgeExecutor(args)
+
+		err := executor.CheckAvailableTokens(
+			context.Background(),
+			[]common.Address{
+				common.BytesToAddress([]byte("eth token")),
+			},
+			[][]byte{
+				[]byte("mvx token"),
+			},
+			[]*big.Int{
+				big.NewInt(1),
+			})
+		assert.ErrorIs(t, err, ErrMintBurnBalance)
+		assert.True(t, tokenMintedBalancesCalled)
+		assert.True(t, accumulatedBurnedTokensCalled)
+	})
+	t.Run("should work with the same balances", func(t *testing.T) {
+		args := createMockExecutorArgs()
+		tokenMintedBalancesCalled := false
+		args.EthereumClient = &bridgeTests.EthereumClientStub{
+			WhitelistedTokensMintBurnCalled: func(ctx context.Context, token common.Address) (bool, error) {
+				return true, nil
+			},
+			TokenMintedBalancesCalled: func(ctx context.Context, token common.Address) (*big.Int, error) {
+				tokenMintedBalancesCalled = true
+
+				return big.NewInt(3700), nil
+			},
+		}
+
+		accumulatedBurnedTokensCalled := false
+		args.MultiversXClient = &bridgeTests.MultiversXClientStub{
+			IsMintBurnAllowedCalled: func(ctx context.Context, token []byte) (bool, error) {
+				return true, nil
+			},
+			AccumulatedBurnedTokensCalled: func(ctx context.Context, token []byte) (*big.Int, error) {
+				accumulatedBurnedTokensCalled = true
+				return big.NewInt(3700), nil
+			},
+		}
+
+		executor, _ := NewBridgeExecutor(args)
+
+		err := executor.CheckAvailableTokens(
+			context.Background(),
+			[]common.Address{
+				common.BytesToAddress([]byte("eth token")),
+			},
+			[][]byte{
+				[]byte("mvx token"),
+			},
+			[]*big.Int{
+				big.NewInt(1),
+			})
+		assert.Nil(t, err)
+		assert.True(t, tokenMintedBalancesCalled)
+		assert.True(t, accumulatedBurnedTokensCalled)
+	})
+	t.Run("should work with higher values on the mvx than eth", func(t *testing.T) {
+		args := createMockExecutorArgs()
+		tokenMintedBalancesCalled := false
+		args.EthereumClient = &bridgeTests.EthereumClientStub{
+			WhitelistedTokensMintBurnCalled: func(ctx context.Context, token common.Address) (bool, error) {
+				return true, nil
+			},
+			TokenMintedBalancesCalled: func(ctx context.Context, token common.Address) (*big.Int, error) {
+				tokenMintedBalancesCalled = true
+
+				return big.NewInt(3699), nil // eth holds less than mvx
+			},
+		}
+
+		accumulatedBurnedTokensCalled := false
+		args.MultiversXClient = &bridgeTests.MultiversXClientStub{
+			IsMintBurnAllowedCalled: func(ctx context.Context, token []byte) (bool, error) {
+				return true, nil
+			},
+			AccumulatedBurnedTokensCalled: func(ctx context.Context, token []byte) (*big.Int, error) {
+				accumulatedBurnedTokensCalled = true
+				return big.NewInt(3700), nil
+			},
+		}
+
+		executor, _ := NewBridgeExecutor(args)
+
+		err := executor.CheckAvailableTokens(
+			context.Background(),
+			[]common.Address{
+				common.BytesToAddress([]byte("eth token")),
+			},
+			[][]byte{
+				[]byte("mvx token"),
+			},
+			[]*big.Int{
+				big.NewInt(1),
+			})
+		assert.Nil(t, err)
+		assert.True(t, tokenMintedBalancesCalled)
+		assert.True(t, accumulatedBurnedTokensCalled)
+	})
+}

bridges/ethMultiversX/errors.go

@@ -40,3 +40,9 @@ var ErrNilSignaturesHolder = errors.New("nil signatures holder")
 
 // ErrNilBatchValidator signals that a nil batch validator was provided
 var ErrNilBatchValidator = errors.New("nil batch validator")
+
+// ErrInvalidSetupMintBurnToken signals that an invalid setup mint burn token was provided
+var ErrInvalidSetupMintBurnToken = errors.New("invalid setup mint burn token")
+
+// ErrMintBurnBalance signals that the mint burn balances are not expected
+var ErrMintBurnBalance = errors.New("mint burn balances are not expected")

bridges/ethMultiversX/interface.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/multiversx/mx-bridge-eth-go/clients"
 	"github.com/multiversx/mx-bridge-eth-go/clients/ethereum/contract"
+	"github.com/multiversx/mx-bridge-eth-go/core/batchProcessor"
 )
 
 // MultiversXClient defines the behavior of the MultiversX client able to communicate with the MultiversX chain
@@ -30,6 +31,8 @@ type MultiversXClient interface {
 	WasSigned(ctx context.Context, actionID uint64) (bool, error)
 	PerformAction(ctx context.Context, actionID uint64, batch *clients.TransferBatch) (string, error)
 	CheckClientAvailability(ctx context.Context) error
+	IsMintBurnAllowed(ctx context.Context, token []byte) (bool, error)
+	AccumulatedBurnedTokens(ctx context.Context, token []byte) (*big.Int, error)
 	Close() error
 	IsInterfaceNil() bool
 }
@@ -38,16 +41,19 @@ type MultiversXClient interface {
 type EthereumClient interface {
 	GetBatch(ctx context.Context, nonce uint64) (*clients.TransferBatch, error)
 	WasExecuted(ctx context.Context, batchID uint64) (bool, error)
-	GenerateMessageHash(batch *clients.TransferBatch) (common.Hash, error)
 	IsDepositSCCall(deposit *clients.DepositTransfer) bool
+	GenerateMessageHash(batch *batchProcessor.ArgListsBatch, batchId uint64) (common.Hash, error)
 
 	BroadcastSignatureForMessageHash(msgHash common.Hash)
-	ExecuteTransfer(ctx context.Context, msgHash common.Hash, batch *clients.TransferBatch, quorum int) (string, error)
+	ExecuteTransfer(ctx context.Context, msgHash common.Hash, batch *batchProcessor.ArgListsBatch, batchId uint64, quorum int) (string, error)
 	GetTransactionsStatuses(ctx context.Context, batchId uint64) ([]byte, error)
 	GetQuorumSize(ctx context.Context) (*big.Int, error)
 	IsQuorumReached(ctx context.Context, msgHash common.Hash) (bool, error)
 	GetBatchSCMetadata(ctx context.Context, nonce uint64) ([]*contract.SCExecProxyERC20SCDeposit, error)
 	CheckClientAvailability(ctx context.Context) error
+	CheckRequiredBalance(ctx context.Context, erc20Address common.Address, value *big.Int) error
+	TokenMintedBalances(ctx context.Context, token common.Address) (*big.Int, error)
+	WhitelistedTokensMintBurn(ctx context.Context, token common.Address) (bool, error)
 	IsInterfaceNil() bool
 }