Merge pull request #926 from rsksmart/feat_fly2217_prioritize_pegin_contract_funds

Feat FLY2217 prioritize pegin contract funds in hot-to-cold transfers

Author: AndresQuijano

internal/adapters/dataproviders/rootstock/bindings.go

@@ -68,6 +68,7 @@ type PeginBinding interface {
 	CallForUser(opts *bind.TransactOpts, quote bindings.QuotesPegInQuote) (*types.Transaction, error)
 	GetBalance(opts *bind.CallOpts, addr common.Address) (*big.Int, error)
 	GetFeePercentage(opts *bind.CallOpts) (*big.Int, error)
+	Withdraw(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)
 }
 
 type PeginContractAdapter interface {

internal/adapters/dataproviders/rootstock/pegin_contract.go

@@ -240,6 +240,42 @@ func (peginContract *peginContractImpl) RegisterPegin(params blockchain.Register
 	return transactionReceipt, nil
 }
 
+// Withdraw withdraws the specified amount from the LP's balance in the pegin contract.
+// It first performs a dry-run call to check for reverts before submitting the actual transaction.
+func (peginContract *peginContractImpl) Withdraw(amount *entities.Wei) error {
+	const functionName = "withdraw"
+	var res []any
+
+	revert := peginContract.contract.Caller().Call(
+		&bind.CallOpts{From: peginContract.signer.Address()}, &res, functionName, amount.AsBigInt(),
+	)
+	parsedRevert, err := ParseRevertReason(peginContract.abis.Flyover, revert)
+	if err != nil && parsedRevert == nil {
+		return fmt.Errorf("error parsing withdraw result: %w", err)
+	} else if parsedRevert != nil {
+		return fmt.Errorf("withdraw reverted with: %s", parsedRevert.Name)
+	}
+
+	opts := &bind.TransactOpts{
+		From:   peginContract.signer.Address(),
+		Signer: peginContract.signer.Sign,
+	}
+
+	receipt, err := rskRetry(peginContract.retryParams.Retries, peginContract.retryParams.Sleep,
+		func() (*geth.Receipt, error) {
+			return awaitTx(peginContract.client, peginContract.miningTimeout, "Withdraw", func() (*geth.Transaction, error) {
+				return peginContract.contract.Withdraw(opts, amount.AsBigInt())
+			})
+		})
+
+	if err != nil {
+		return fmt.Errorf("withdraw error: %w", err)
+	} else if receipt == nil || receipt.Status == 0 {
+		return errors.New("withdraw error: transaction failed")
+	}
+	return nil
+}
+
 // parsePeginQuote parses a quote.PeginQuote into a bindings.QuotesPegInQuote. All BTC address fields support all address types
 // except for FedBtcAddress which must be a P2SH address.
 func parsePeginQuote(peginQuote quote.PeginQuote) (bindings.QuotesPegInQuote, error) {

internal/adapters/dataproviders/rootstock/pegin_contract_test.go

@@ -425,3 +425,93 @@ func TestPeginContractImpl_RegisterPegin_ErrorHandling(t *testing.T) {
 		assert.Empty(t, result)
 	})
 }
+
+func TestPeginContractImpl_Withdraw(t *testing.T) {
+	contractBinding := &mocks.PeginContractAdapterMock{}
+	signerMock := &mocks.TransactionSignerMock{}
+	mockClient := &mocks.RpcClientBindingMock{}
+	callerMock := &mocks.ContractCallerBindingMock{}
+	peginContract := rootstock.NewPeginContractImpl(
+		rootstock.NewRskClient(mockClient),
+		test.AnyAddress,
+		contractBinding,
+		signerMock,
+		rootstock.RetryParams{},
+		time.Duration(1),
+		Abis,
+	)
+	withdrawAmount := entities.NewWei(5000000000000000000)
+	matchOptsFunc := func(opts *bind.TransactOpts) bool {
+		return opts.From.String() == parsedAddress.String()
+	}
+	t.Run("Success", func(t *testing.T) {
+		contractBinding.On("Caller").Return(callerMock).Once()
+		callerMock.On("Call", mock.Anything, mock.Anything, "withdraw", withdrawAmount.AsBigInt()).Return(nil).Once()
+		tx := prepareTxMocks(mockClient, signerMock, true)
+		contractBinding.On("Withdraw", mock.MatchedBy(matchOptsFunc), withdrawAmount.AsBigInt()).Return(tx, nil).Once()
+		err := peginContract.Withdraw(withdrawAmount)
+		require.NoError(t, err)
+		contractBinding.AssertExpectations(t)
+		callerMock.AssertExpectations(t)
+	})
+}
+
+// nolint:funlen
+func TestPeginContractImpl_Withdraw_ErrorHandling(t *testing.T) {
+	contractBinding := &mocks.PeginContractAdapterMock{}
+	signerMock := &mocks.TransactionSignerMock{}
+	mockClient := &mocks.RpcClientBindingMock{}
+	callerMock := &mocks.ContractCallerBindingMock{}
+	peginContract := rootstock.NewPeginContractImpl(
+		rootstock.NewRskClient(mockClient),
+		test.AnyAddress,
+		contractBinding,
+		signerMock,
+		rootstock.RetryParams{},
+		time.Duration(1),
+		Abis,
+	)
+	withdrawAmount := entities.NewWei(5000000000000000000)
+	signerMock.On("Address").Return(parsedAddress)
+	matchOptsFunc := func(opts *bind.TransactOpts) bool {
+		return opts.From.String() == parsedAddress.String()
+	}
+	t.Run("Error handling (dry-run revert NoBalance)", func(t *testing.T) {
+		e := NewRskRpcError("transaction reverted", "0x29226653")
+		contractBinding.On("Caller").Return(callerMock).Once()
+		callerMock.On("Call", mock.Anything, mock.Anything, "withdraw", withdrawAmount.AsBigInt()).Return(e).Once()
+		err := peginContract.Withdraw(withdrawAmount)
+		require.ErrorContains(t, err, "withdraw reverted with: NoBalance")
+		contractBinding.AssertNotCalled(t, "Withdraw", mock.Anything, mock.Anything)
+		contractBinding.AssertExpectations(t)
+		callerMock.AssertExpectations(t)
+	})
+	t.Run("Error handling (dry-run parse error)", func(t *testing.T) {
+		contractBinding.On("Caller").Return(callerMock).Once()
+		callerMock.On("Call", mock.Anything, mock.Anything, "withdraw", withdrawAmount.AsBigInt()).Return(assert.AnError).Once()
+		err := peginContract.Withdraw(withdrawAmount)
+		require.ErrorContains(t, err, "error parsing withdraw result")
+		contractBinding.AssertExpectations(t)
+		callerMock.AssertExpectations(t)
+	})
+	t.Run("Error handling (transaction send error)", func(t *testing.T) {
+		contractBinding.On("Caller").Return(callerMock).Once()
+		callerMock.On("Call", mock.Anything, mock.Anything, "withdraw", withdrawAmount.AsBigInt()).Return(nil).Once()
+		_ = prepareTxMocks(mockClient, signerMock, true)
+		contractBinding.On("Withdraw", mock.MatchedBy(matchOptsFunc), withdrawAmount.AsBigInt()).Return(nil, assert.AnError).Once()
+		err := peginContract.Withdraw(withdrawAmount)
+		require.ErrorContains(t, err, "withdraw error")
+		contractBinding.AssertExpectations(t)
+		callerMock.AssertExpectations(t)
+	})
+	t.Run("Error handling (transaction reverted)", func(t *testing.T) {
+		contractBinding.On("Caller").Return(callerMock).Once()
+		callerMock.On("Call", mock.Anything, mock.Anything, "withdraw", withdrawAmount.AsBigInt()).Return(nil).Once()
+		tx := prepareTxMocks(mockClient, signerMock, false)
+		contractBinding.On("Withdraw", mock.MatchedBy(matchOptsFunc), withdrawAmount.AsBigInt()).Return(tx, nil).Once()
+		err := peginContract.Withdraw(withdrawAmount)
+		require.ErrorContains(t, err, "withdraw error: transaction failed")
+		contractBinding.AssertExpectations(t)
+		callerMock.AssertExpectations(t)
+	})
+}

internal/configuration/registry/usecase.go

@@ -383,6 +383,7 @@ func NewUseCaseRegistry(
 			lpRegistry.ColdWallet,
 			btcRegistry.PaymentWallet,
 			rskRegistry.Wallet,
+			rskRegistry.Contracts,
 			messaging.Rpc,
 			mutexes.BtcWalletMutex(),
 			mutexes.RskWalletMutex(),

internal/entities/blockchain/lbc.go

@@ -85,6 +85,7 @@ type PeginContract interface {
 	CallForUser(txConfig TransactionConfig, peginQuote quote.PeginQuote) (TransactionReceipt, error)
 	RegisterPegin(params RegisterPeginParams) (TransactionReceipt, error)
 	DaoFeePercentage() (uint64, error)
+	Withdraw(amount *entities.Wei) error
 }
 
 type PegoutContract interface {

internal/usecases/liquidity_provider/transfer_excess_to_cold_wallet.go

@@ -51,6 +51,11 @@ type TransferToColdWalletResult struct {
 	RskResult NetworkTransferResult
 }
 
+type currentLiquidityResult struct {
+	Btc  *entities.Wei
+	Rbtc *entities.Wei
+}
+
 func NewTransferToColdWalletResult(btcResult, rskResult NetworkTransferResult) *TransferToColdWalletResult {
 	return &TransferToColdWalletResult{
 		BtcResult: btcResult,
@@ -79,6 +84,7 @@ type TransferExcessToColdWalletUseCase struct {
 	coldWallet                   cold_wallet.ColdWallet
 	btcWallet                    blockchain.BitcoinWallet
 	rskWallet                    blockchain.RootstockWallet
+	contracts                    blockchain.RskContracts
 	rpc                          blockchain.Rpc
 	btcWalletMutex               sync.Locker
 	rskWalletMutex               sync.Locker
@@ -101,6 +107,7 @@ func NewTransferExcessToColdWalletUseCase(
 	coldWallet cold_wallet.ColdWallet,
 	btcWallet blockchain.BitcoinWallet,
 	rskWallet blockchain.RootstockWallet,
+	contracts blockchain.RskContracts,
 	rpc blockchain.Rpc,
 	btcWalletMutex sync.Locker,
 	rskWalletMutex sync.Locker,
@@ -121,6 +128,7 @@ func NewTransferExcessToColdWalletUseCase(
 		coldWallet:                   coldWallet,
 		btcWallet:                    btcWallet,
 		rskWallet:                    rskWallet,
+		contracts:                    contracts,
 		rpc:                          rpc,
 		btcWalletMutex:               btcWalletMutex,
 		rskWalletMutex:               rskWalletMutex,
@@ -349,6 +357,7 @@ func (useCase *TransferExcessToColdWalletUseCase) publishRskTransferEvent(ctx co
 	}
 }
 
+// sendTransferAlert triggers the alertSender to send an alert with the transfer details.
 func (useCase *TransferExcessToColdWalletUseCase) sendTransferAlert(ctx context.Context, asset string, amount *entities.Wei, txHash string, fee *entities.Wei, isTimeForcing bool) error {
 	reason := "threshold"
 	if isTimeForcing {
@@ -376,6 +385,9 @@ func (useCase *TransferExcessToColdWalletUseCase) handleRskTransfer(ctx context.
 		}
 	}
 
+	// In order to give priority to the contract funds, we withdraw them before the transfer
+	useCase.withdrawContractFunds()
+
 	txResult, err := useCase.executeRskTransfer(ctx, excess)
 	if err == nil {
 		useCase.publishRskTransferEvent(ctx, txResult, isTimeForcingTransfer)
@@ -403,9 +415,22 @@ func (useCase *TransferExcessToColdWalletUseCase) handleRskTransfer(ctx context.
 	}
 }
 
-type currentLiquidityResult struct {
-	Btc  *entities.Wei
-	Rbtc *entities.Wei
+// withdrawContractFunds retrieves the LP's balance from the pegin contract and withdraws it
+// back to the hot wallet, ensuring contract funds are prioritized before cold wallet transfers.
+func (useCase *TransferExcessToColdWalletUseCase) withdrawContractFunds() {
+	lpAddress := useCase.generalProvider.RskAddress()
+	contractBalance, err := useCase.contracts.PegIn.GetBalance(lpAddress)
+	if err != nil {
+		log.Errorf("TransferExcessToColdWallet: failed to get pegin contract balance: %v", err)
+		return
+	}
+	if contractBalance.Cmp(entities.NewWei(0)) <= 0 {
+		return
+	}
+	log.Infof("TransferExcessToColdWallet: withdrawing %s wei from pegin contract", contractBalance.String())
+	if err := useCase.contracts.PegIn.Withdraw(contractBalance); err != nil {
+		log.Errorf("TransferExcessToColdWallet: failed to withdraw from pegin contract: %v", err)
+	}
 }
 
 // validateColdWallet checks that both BTC and RSK cold wallet addresses are configured.