add swapAndLombardTransfer

EurekaHandler/script/Upgrade.s.sol

@@ -15,7 +15,7 @@ contract DeploymentScript is Script {
 
         vm.startBroadcast();
 
-        EurekaHandler handler = EurekaHandler(0x46914a36365EC16600D81880903f3e95dcea3e5D);
+        EurekaHandler handler = EurekaHandler(0xFc2d0487A0ae42ae7329a80dc269916A9184cF7C);
 
         EurekaHandler newHandlerImplementation = new EurekaHandler();
 

EurekaHandler/src/EurekaHandler.sol

@@ -85,8 +85,7 @@ contract EurekaHandler is IEurekaHandler, Initializable, UUPSUpgradeable, Ownabl
 
             amountOut = _swap(swapInputToken, transferParams.token, swapInputAmount, swapCalldata);
         }
-
-
+
         if (amountOut <= _totalFees(fees)) {
             revert("Insufficient amount out to cover fees");
         }
@@ -113,6 +112,58 @@ contract EurekaHandler is IEurekaHandler, Initializable, UUPSUpgradeable, Ownabl
         emit EurekaTransfer(transferParams.token, amountOutAfterFees, fees.relayFee, fees.relayFeeRecipient);
     }
 
+    function swapAndLombardTransfer(
+        address swapInputToken,
+        uint256 swapInputAmount,
+        bytes memory swapCalldata,
+        uint256 minAmountOut,
+        TransferParams memory transferParams,
+        Fees memory fees
+    ) external payable {
+        require(block.timestamp < fees.quoteExpiry, "Fee quote expired");
+
+        uint256 amountOut;
+        if (swapInputToken == address(0)) {
+            require(msg.value == swapInputAmount, "Insufficient native token");
+
+            amountOut = _swapNative(address(lbtc), swapInputAmount, swapCalldata);
+        } else {
+            IERC20(swapInputToken).safeTransferFrom(msg.sender, address(this), swapInputAmount);
+
+            amountOut = _swap(swapInputToken, address(lbtc), swapInputAmount, swapCalldata);
+        }
+
+        if (amountOut <= _totalFees(fees)) {
+            revert("Insufficient amount out to cover fees");
+        }
+
+        // Collect fees
+        if (fees.relayFee > 0) {
+            IERC20(lbtc).safeTransfer(fees.relayFeeRecipient, fees.relayFee);
+        }
+
+        uint256 amountOutAfterFees = amountOut - _totalFees(fees);
+
+        IERC20(lbtc).forceApprove(lbtcVoucher, amountOutAfterFees);
+
+        uint256 voucherAmount = IIBCVoucher(lbtcVoucher).wrap(amountOutAfterFees, minAmountOut);
+
+
+         _sendTransfer(
+            IICS20TransferMsgs.SendTransferMsg({
+                denom: lbtcVoucher,
+                amount: voucherAmount,
+                receiver: transferParams.recipient,
+                sourceClient: transferParams.sourceClient,
+                destPort: transferParams.destPort,
+                timeoutTimestamp: transferParams.timeoutTimestamp,
+                memo: transferParams.memo
+            })
+        );
+
+        emit EurekaTransfer(lbtcVoucher, voucherAmount, fees.relayFee, fees.relayFeeRecipient);
+    }
+
     function lombardTransfer(
         uint256 amount,
         uint256 minAmountOut,

EurekaHandler/src/interfaces/IEurekaHandler.sol

@@ -27,6 +27,15 @@ interface IEurekaHandler {
         Fees memory fees
     ) external payable;
 
+    function swapAndLombardTransfer(
+        address swapInputToken,
+        uint256 swapInputAmount,
+        bytes memory swapCalldata,
+        uint256 minAmountOut,
+        TransferParams memory transferParams,
+        Fees memory fees
+    ) external payable;
+
     function lombardTransfer(
         uint256 amount,
         uint256 minAmountOut,

EurekaHandler/test/EurekaHandler.t.sol

@@ -288,6 +288,78 @@ contract EurekaHandlerTest is Test {
         handler.lombardTransfer(amountIn, 99000000, transferParams, fees);
     }
 
+    function testSwapAndLombardTransfer() public {
+        address weth = 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14;
+
+        uint256 amountIn = 1000000000;
+
+        bytes memory swapCalldata = _encodeSwapExactInputCalldata(weth, lbtc, 500, address(handler), amountIn, 0, 0);
+
+        IEurekaHandler.TransferParams memory transferParams = IEurekaHandler.TransferParams({
+            token: lbtcVoucher,
+            recipient: "cosmos1234",
+            sourceClient: "client-0",
+            destPort: "transfer",
+            timeoutTimestamp: uint64(block.timestamp + 100),
+            memo: ""
+        });
+
+        IEurekaHandler.Fees memory fees = IEurekaHandler.Fees({
+            relayFee: 100,
+            relayFeeRecipient: relayFeeRecipient,
+            quoteExpiry: uint64(block.timestamp + 100)
+        });        
+
+        address alice = makeAddr("alice");
+
+        vm.mockCall(
+            weth,
+            abi.encodeWithSelector(IERC20.transferFrom.selector, alice, address(handler), amountIn),
+            abi.encode(true)
+        );
+
+        vm.mockCall(
+            lbtc,
+            abi.encodeWithSelector(IERC20.transferFrom.selector, address(handler), relayFeeRecipient, fees.relayFee),
+            abi.encode(true)
+        );
+
+        {
+            bytes[] memory lbtcBalanceMockResponses = new bytes[](2);
+            lbtcBalanceMockResponses[0] = abi.encode(0);
+            lbtcBalanceMockResponses[1] = abi.encode(100000000);
+
+            vm.mockCalls(
+                lbtc, abi.encodeWithSelector(IERC20.balanceOf.selector, address(handler)), lbtcBalanceMockResponses
+            );
+        }        
+
+        vm.mockCall(
+            lbtcVoucher, abi.encodeWithSelector(IIBCVoucher.wrap.selector, 99999900, 99000000), abi.encode(99000000)
+        );        
+
+        vm.mockCall(
+            address(ics20Transfer),
+            abi.encodeWithSelector(
+                IICS20Transfer.sendTransferWithSender.selector,
+                IICS20TransferMsgs.SendTransferMsg({
+                    denom: lbtcVoucher,
+                    amount: 99000000,
+                    receiver: transferParams.recipient,
+                    sourceClient: transferParams.sourceClient,
+                    destPort: transferParams.destPort,
+                    timeoutTimestamp: transferParams.timeoutTimestamp,
+                    memo: transferParams.memo
+                }),
+                alice
+            ),
+            abi.encode(1)
+        );
+
+        vm.startPrank(alice);
+        handler.swapAndLombardTransfer(weth, amountIn, swapCalldata, 99000000, transferParams, fees);
+    }
+
     function _encodeSwapExactInputCalldata(
         address tokenIn,
         address tokenOut,