Merge pull request #885 from rsksmart/v.2.5.0

V.2.5.0

Author: alexjavabraz

.mockery.yaml

@@ -14,15 +14,17 @@ packages:
       sesClient:
   github.com/rsksmart/liquidity-provider-server/internal/adapters/dataproviders/rootstock:
     interfaces:
-      LbcBinding:
       RskBridgeBinding:
       TransactionSigner:
       RpcClientBinding:
-      LbcCallerBinding:
-      LbcAdapter:
       RskBridgeAdapter:
       EventIteratorAdapter:
       RskSignerWallet:
+      PeginContractAdapter:
+      PegoutContractAdapter:
+      CollateralManagementAdapter:
+      DiscoveryBinding:
+      ContractCallerBinding:
   github.com/rsksmart/liquidity-provider-server/internal/adapters/dataproviders/database/mongo:
     interfaces:
       DbClientBinding:
@@ -38,6 +40,8 @@ packages:
       DefaultCredentialsProvider:
   github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/rest/handlers:
     interfaces:
+      ResignUseCase:
+      AcceptQuoteUseCase:
       AddPeginCollateralUseCase:
       AddPegoutCollateralUseCase:
       ChangeStatusUseCase:
@@ -62,7 +66,6 @@ packages:
       GetPeginReportUseCase:
       RecommendedPegoutUseCase:
       RecommendedPeginUseCase:
-      ResignUseCase:
       GetRevenueReportUseCase:
       GetSummariesReportUseCase:
       GetTrustedAccountsUseCase:
@@ -82,9 +85,13 @@ packages:
         PegConfiguration:
   github.com/rsksmart/liquidity-provider-server/internal/entities/blockchain:
     interfaces:
+      Pausable:
       BitcoinWallet:
       RootstockRpcServer:
-      LiquidityBridgeContract:
+      PeginContract:
+      PegoutContract:
+      DiscoveryContract:
+      CollateralManagementContract:
   github.com/rsksmart/liquidity-provider-server/internal/entities/rootstock:
     interfaces:
       BatchPegOutRepository:
@@ -108,3 +115,9 @@ packages:
     interfaces:
       EclipseCheckUseCase:
       UpdateBtcReleaseUseCase:
+  github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/watcher/monitoring:
+    interfaces:
+      GetAssetReportUseCase:
+  github.com/prometheus/client_golang/prometheus:
+    interfaces:
+      Registerer:

Makefile

@@ -17,7 +17,8 @@ tools: download
 	go install golang.org/x/vuln/cmd/govulncheck@latest
 	pip3 install pre-commit && pre-commit install
 	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(shell go env GOPATH)/bin v1.63.4
-	go install github.com/vektra/mockery/v2@v2.53.0  	# ensures mockery version 2.53.0 is installed
+	go install github.com/ethereum/go-ethereum/cmd/abigen@eb00f1694c9265f6909c19995a535eef246dcf1e # v1.14.13
+	go install github.com/vektra/mockery/v2@v2.53.1  	# ensures mockery version 2.53.1 is installed
 
 download:
 	go mod download
@@ -87,3 +88,6 @@ monitoring:
 		-p $(MONITOR_PORT):$(MONITOR_PORT) \
 		-e MONITOR_PORT=$(MONITOR_PORT) \
 		monitoring
+
+bindings:
+	./scripts/create-bindings.sh $(IMAGE) && echo "Bindings generated successfully"

OpenApi.yml

@@ -1030,6 +1030,14 @@ paths:
         "204":
           description: ""
       summary: Update Trusted Account
+  /metrics:
+    get:
+      description: ' Returns a predefined set of metrics to be consumed by a monitoring
+        system.'
+      responses:
+        "200":
+          description: ""
+      summary: Metrics
   /pegin/acceptAuthenticatedQuote:
     post:
       description: ' Accepts Quote with trusted account signature'

cmd/application/lps/application.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
+	"syscall"
+
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/dataproviders"
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/rest/server"
 	"github.com/rsksmart/liquidity-provider-server/internal/adapters/entrypoints/watcher"
@@ -17,8 +20,6 @@ import (
 	"github.com/rsksmart/liquidity-provider-server/internal/entities/blockchain"
 	"github.com/rsksmart/liquidity-provider-server/internal/usecases"
 	log "github.com/sirupsen/logrus"
-	"os"
-	"syscall"
 )
 
 type Application struct {
@@ -126,7 +127,7 @@ func (app *Application) Run(env environment.Environment, logLevel log.Level) {
 	app.addRunningService(app.btcRegistry.MonitoringWallet)
 	app.addRunningService(app.messagingRegistry.EventBus)
 
-	registerParams := blockchain.NewProviderRegistrationParams(app.env.Provider.Name, app.env.Provider.ApiBaseUrl, true, app.env.Provider.ProviderType)
+	registerParams := blockchain.NewProviderRegistrationParams(app.env.Provider.Name, app.env.Provider.ApiBaseUrl, true, app.env.Provider.ProviderType())
 	id, err := app.useCaseRegistry.GetRegistrationUseCase().Run(registerParams)
 	if errors.Is(err, usecases.AlreadyRegisteredError) {
 		log.Info("Provider already registered")
@@ -171,6 +172,8 @@ func (app *Application) prepareWatchers() ([]watcher.Watcher, error) {
 		app.watcherRegistry.PenalizationAlertWatcher,
 		app.watcherRegistry.PegoutBridgeWatcher,
 		app.watcherRegistry.BtcReleaseWatcher,
+		app.watcherRegistry.QuoteMetricsWatcher,
+		app.watcherRegistry.AssetReportWatcher,
 	}
 
 	if app.env.Eclipse.Enabled {

cmd/utils/defaults/defaults.go

@@ -9,24 +9,36 @@ func GetRsk(network string) (environment.RskEnv, error) {
 	switch network {
 	case "regtest":
 		return environment.RskEnv{
-			ChainId:       33,
-			LbcAddress:    "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
-			BridgeAddress: "0x0000000000000000000000000000000001000006",
-			AccountNumber: 0,
+			ChainId: 33,
+			// TODO add addresses when deplpoyed
+			PeginContractAddress:        "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			PegoutContractAddress:       "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			DiscoveryAddress:            "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			CollateralManagementAddress: "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			BridgeAddress:               "0x0000000000000000000000000000000001000006",
+			AccountNumber:               0,
 		}, nil
 	case "testnet":
 		return environment.RskEnv{
-			ChainId:       31,
-			LbcAddress:    "0xc2a630c053d12d63d32b025082f6ba268db18300",
-			BridgeAddress: "0x0000000000000000000000000000000001000006",
-			AccountNumber: 0,
+			ChainId: 31,
+			// TODO add addresses when deplpoyed
+			PeginContractAddress:        "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			PegoutContractAddress:       "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			DiscoveryAddress:            "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			CollateralManagementAddress: "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			BridgeAddress:               "0x0000000000000000000000000000000001000006",
+			AccountNumber:               0,
 		}, nil
 	case "mainnet":
 		return environment.RskEnv{
-			ChainId:       30,
-			LbcAddress:    "0xaa9caf1e3967600578727f975f283446a3da6612",
-			BridgeAddress: "0x0000000000000000000000000000000001000006",
-			AccountNumber: 0,
+			ChainId: 30,
+			// TODO add addresses when deplpoyed
+			PeginContractAddress:        "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			PegoutContractAddress:       "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			DiscoveryAddress:            "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			CollateralManagementAddress: "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8",
+			BridgeAddress:               "0x0000000000000000000000000000000001000006",
+			AccountNumber:               0,
 		}, nil
 	default:
 		return environment.RskEnv{}, errors.New("invalid network")

cmd/utils/refund_user_pegout/refund_user_pegout.go

@@ -34,12 +34,12 @@ func main() {
 	}
 
 	ctx := context.Background()
-	lbc, err := scripts.CreateLiquidityBridgeContract(ctx, bootstrap.Rootstock, env, environment.DefaultTimeouts())
+	pegoutContract, err := scripts.CreatePegoutContract(ctx, bootstrap.Rootstock, env, environment.DefaultTimeouts())
 	if err != nil {
 		scripts.ExitWithError(2, "Error accessing the Liquidity Bridge Contract", err)
 	}
 
-	txHash, err := ExecuteRefundUserPegOut(lbc, scriptInput.QuoteHashBytes)
+	txHash, err := ExecuteRefundUserPegOut(pegoutContract, scriptInput.QuoteHashBytes)
 	if err != nil {
 		scripts.ExitWithError(2, "Error on transaction execution", err)
 	}
@@ -53,7 +53,7 @@ func ReadRefundUserPegOutScriptInput(scriptInput *RefundUserPegOutScriptInput) {
 	flag.StringVar(&scriptInput.AwsLocalEndpoint, "aws-endpoint", "http://localhost:4566", "AWS endpoint for localstack")
 	flag.StringVar(&scriptInput.SecretSource, "secret-src", "", "The source of the secrets to execute the transaction. Must be one of the following: env, aws")
 	flag.StringVar(&scriptInput.RskEndpoint, "rsk-endpoint", "", "The URL of the RSK RPC server. E.g. http://localhost:4444")
-	flag.StringVar(&scriptInput.CustomLbcAddress, "lbc-address", "", "Custom address of the liquidity bridge contract. If not provided will use the network default.")
+	flag.StringVar(&scriptInput.CustomPegoutAddress, "custom-pegout-address", "", "Custom address of the pegout contract. If not provided will use the network default.")
 
 	flag.StringVar(&scriptInput.KeystoreFile, "keystore-file", "", "Path to the keystore file. Only required if the secret source is env")
 	flag.StringVar(&scriptInput.EncryptedJsonSecret, "keystore-secret", "", "Name of the secret storing the keystore. Only required if the secret source is aws")
@@ -71,6 +71,6 @@ func ParseRefundUserPegOutScriptInput(parse scripts.ParseFunc, scriptInput *Refu
 	return scriptInput.BaseInput.ToEnv(pwdReader)
 }
 
-func ExecuteRefundUserPegOut(lbc blockchain.LiquidityBridgeContract, quoteHash string) (string, error) {
-	return lbc.RefundUserPegOut(quoteHash)
+func ExecuteRefundUserPegOut(pegoutContract blockchain.PegoutContract, quoteHash string) (string, error) {
+	return pegoutContract.RefundUserPegOut(quoteHash)
 }

cmd/utils/refund_user_pegout/refund_user_pegout_test.go

@@ -92,17 +92,17 @@ func TestParseRefundUserPegOutScriptInput(t *testing.T) {
 
 func TestRefundUserPegOut(t *testing.T) {
 	t.Run("should execute refund user peg out successfully", func(t *testing.T) {
-		lbc := &mocks.LiquidityBridgeContractMock{}
+		pegoutContract := &mocks.PegoutContractMock{}
 		expectedTxHash := test.AnyHash
 
 		// Setup mock expectations
-		lbc.On("RefundUserPegOut", testQuoteHash).Return(expectedTxHash, nil)
+		pegoutContract.On("RefundUserPegOut", testQuoteHash).Return(expectedTxHash, nil)
 
-		txHash, err := ExecuteRefundUserPegOut(lbc, testQuoteHash)
+		txHash, err := ExecuteRefundUserPegOut(pegoutContract, testQuoteHash)
 		require.NoError(t, err)
 		assert.Equal(t, expectedTxHash, txHash)
 
 		// Verify all expectations were met
-		lbc.AssertExpectations(t)
+		pegoutContract.AssertExpectations(t)
 	})
 }

cmd/utils/register_pegin/register_pegin.go

@@ -89,12 +89,12 @@ func main() {
 		scripts.ExitWithError(errorCode, "Error connecting to BTC node", err)
 	}
 
-	lbc, err := scripts.CreateLiquidityBridgeContract(ctx, bootstrap.Rootstock, env, environment.DefaultTimeouts())
+	peginContract, err := scripts.CreatePeginContract(ctx, bootstrap.Rootstock, env, environment.DefaultTimeouts())
 	if err != nil {
 		scripts.ExitWithError(errorCode, "Error accessing the Liquidity Bridge Contract", err)
 	}
 
-	receipt, err := ExecuteRegisterPegIn(bitcoin.NewBitcoindRpc(btcClient), lbc, parsedInput)
+	receipt, err := ExecuteRegisterPegIn(bitcoin.NewBitcoindRpc(btcClient), peginContract, parsedInput)
 	if err != nil {
 		scripts.ExitWithError(errorCode, "Error executing register PegIn", err)
 	}
@@ -151,7 +151,7 @@ func ParseRegisterPegInScriptInput(parse scripts.ParseFunc, scriptInput *Registe
 
 func ExecuteRegisterPegIn(
 	btcRpc blockchain.BitcoinNetwork,
-	lbc blockchain.LiquidityBridgeContract,
+	peginContract blockchain.PeginContract,
 	parsedInput ParsedRegisterPegInInput,
 ) (blockchain.TransactionReceipt, error) {
 	var pmt, rawTx []byte
@@ -168,7 +168,7 @@ func ExecuteRegisterPegIn(
 		return blockchain.TransactionReceipt{}, err
 	}
 
-	return lbc.RegisterPegin(blockchain.RegisterPeginParams{
+	return peginContract.RegisterPegin(blockchain.RegisterPeginParams{
 		QuoteSignature:        parsedInput.Signature,
 		BitcoinRawTransaction: rawTx,
 		PartialMerkleTree:     pmt,

cmd/utils/register_pegin/register_pegin_test.go

@@ -72,75 +72,75 @@ func TestExecuteRegisterPegIn(t *testing.T) {
 	}
 	t.Run("should execute RegisterPegIn successfully", func(t *testing.T) {
 		rpc := new(mocks.BtcRpcMock)
-		lbc := new(mocks.LiquidityBridgeContractMock)
+		peginContract := new(mocks.PeginContractMock)
 		rpc.On("GetPartialMerkleTree", parsedInput.BtcTxHash).Return(pmt, nil).Once()
 		rpc.On("GetRawTransaction", parsedInput.BtcTxHash).Return(rawTx, nil).Once()
 		rpc.On("GetTransactionBlockInfo", parsedInput.BtcTxHash).Return(blockInfo, nil).Once()
-		lbc.On("RegisterPegin", blockchain.RegisterPeginParams{
+		peginContract.On("RegisterPegin", blockchain.RegisterPeginParams{
 			QuoteSignature: parsedInput.Signature, BitcoinRawTransaction: rawTx,
 			PartialMerkleTree: pmt, BlockHeight: blockHeight, Quote: parsedInput.Quote,
 		}).Return(expectedReceipt, nil).Once()
 
-		result, err := ExecuteRegisterPegIn(rpc, lbc, parsedInput)
+		result, err := ExecuteRegisterPegIn(rpc, peginContract, parsedInput)
 		require.NoError(t, err)
 		assert.Equal(t, expectedReceipt, result)
 		rpc.AssertExpectations(t)
-		lbc.AssertExpectations(t)
+		peginContract.AssertExpectations(t)
 	})
 
 	t.Run("should return error if GetPartialMerkleTree fails", func(t *testing.T) {
 		rpc := new(mocks.BtcRpcMock)
-		lbc := new(mocks.LiquidityBridgeContractMock)
+		peginContract := new(mocks.PeginContractMock)
 		rpc.On("GetPartialMerkleTree", parsedInput.BtcTxHash).Return([]byte{}, assert.AnError).Once()
 
-		result, err := ExecuteRegisterPegIn(rpc, lbc, parsedInput)
+		result, err := ExecuteRegisterPegIn(rpc, peginContract, parsedInput)
 		require.Error(t, err)
 		assert.Equal(t, blockchain.TransactionReceipt{}, result)
 		rpc.AssertExpectations(t)
-		lbc.AssertNotCalled(t, "RegisterPegin")
+		peginContract.AssertNotCalled(t, "RegisterPegin")
 	})
 
 	t.Run("should return error if GetRawTransaction fails", func(t *testing.T) {
 		rpc := new(mocks.BtcRpcMock)
-		lbc := new(mocks.LiquidityBridgeContractMock)
+		peginContract := new(mocks.PeginContractMock)
 		rpc.On("GetPartialMerkleTree", parsedInput.BtcTxHash).Return(pmt, nil).Once()
 		rpc.On("GetRawTransaction", parsedInput.BtcTxHash).Return([]byte{}, assert.AnError).Once()
 
-		result, err := ExecuteRegisterPegIn(rpc, lbc, parsedInput)
+		result, err := ExecuteRegisterPegIn(rpc, peginContract, parsedInput)
 		require.Error(t, err)
 		assert.Equal(t, blockchain.TransactionReceipt{}, result)
 		rpc.AssertExpectations(t)
-		lbc.AssertNotCalled(t, "RegisterPegin")
+		peginContract.AssertNotCalled(t, "RegisterPegin")
 	})
 
 	t.Run("should return error if GetTransactionBlockInfo fails", func(t *testing.T) {
 		rpc := new(mocks.BtcRpcMock)
-		lbc := new(mocks.LiquidityBridgeContractMock)
+		peginContract := new(mocks.PeginContractMock)
 		rpc.On("GetPartialMerkleTree", parsedInput.BtcTxHash).Return(pmt, nil).Once()
 		rpc.On("GetRawTransaction", parsedInput.BtcTxHash).Return(rawTx, nil).Once()
 		rpc.On("GetTransactionBlockInfo", parsedInput.BtcTxHash).Return(blockchain.BitcoinBlockInformation{}, assert.AnError).Once()
 
-		result, err := ExecuteRegisterPegIn(rpc, lbc, parsedInput)
+		result, err := ExecuteRegisterPegIn(rpc, peginContract, parsedInput)
 
 		require.Error(t, err)
 		assert.Equal(t, blockchain.TransactionReceipt{}, result)
 		rpc.AssertExpectations(t)
-		lbc.AssertNotCalled(t, "RegisterPegin")
+		peginContract.AssertNotCalled(t, "RegisterPegin")
 	})
 
 	t.Run("should return error if RegisterPegin fails", func(t *testing.T) {
 		rpc := new(mocks.BtcRpcMock)
-		lbc := new(mocks.LiquidityBridgeContractMock)
+		peginContract := new(mocks.PeginContractMock)
 		rpc.On("GetPartialMerkleTree", parsedInput.BtcTxHash).Return(pmt, nil).Once()
 		rpc.On("GetRawTransaction", parsedInput.BtcTxHash).Return(rawTx, nil).Once()
 		rpc.On("GetTransactionBlockInfo", parsedInput.BtcTxHash).Return(blockInfo, nil).Once()
-		lbc.On("RegisterPegin", mock.Anything).Return(blockchain.TransactionReceipt{}, assert.AnError).Once()
+		peginContract.On("RegisterPegin", mock.Anything).Return(blockchain.TransactionReceipt{}, assert.AnError).Once()
 
-		result, err := ExecuteRegisterPegIn(rpc, lbc, parsedInput)
+		result, err := ExecuteRegisterPegIn(rpc, peginContract, parsedInput)
 		require.Error(t, err)
 		assert.Equal(t, blockchain.TransactionReceipt{}, result)
 		rpc.AssertExpectations(t)
-		lbc.AssertExpectations(t)
+		peginContract.AssertExpectations(t)
 	})
 }
 
@@ -163,7 +163,7 @@ func TestRegisterPegInScriptInput_ToEnv(t *testing.T) {
 		assert.Equal(t, "btcPassword", env.Btc.Password)
 		// we assert the rsk defaults to ensure the method called its parent method
 		assert.Equal(t, uint64(33), env.Rsk.ChainId)
-		assert.Equal(t, "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8", env.Rsk.LbcAddress)
+		assert.Equal(t, "0x8901a2bbf639bfd21a97004ba4d7ae2bd00b8da8", env.Rsk.PeginContractAddress)
 		assert.Equal(t, "0x0000000000000000000000000000000001000006", env.Rsk.BridgeAddress)
 		assert.Equal(t, 0, env.Rsk.AccountNumber)
 	})