wormhole-nativeswap-example/contracts/contracts/CrossChainSwapV3.sol

// SPDX-License-Identifier: Apache 2

pragma solidity ^0.7.6;
pragma abicoder v2;

import './shared/IWormhole.sol';
import './shared/SwapHelper.sol';
import './shared/TokenBridge.sol';
import './shared/WETH.sol';
import 'solidity-bytes-utils/contracts/BytesLib.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import '@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol';
import '@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol';


interface IUniswapRouter is ISwapRouter {
    function refundETH() external payable;
}


/// @title A cross-chain UniswapV3 example 
/// @notice Swaps against UniswapV3 pools and uses Wormhole TokenBridge
/// for cross-chain transfers
contract CrossChainSwapV3 {
    using SafeERC20 for IERC20;
    using BytesLib for bytes;
    uint8 public immutable TypeExactIn = 1;
    uint8 public immutable TypeExactOut = 2;
    IUniswapRouter public immutable SWAP_ROUTER;
    address public immutable FEE_TOKEN_ADDRESS;
    address public immutable TOKEN_BRIDGE_ADDRESS;
    address public immutable WRAPPED_NATIVE;

    constructor(
        address _swapRouterAddress, 
        address _feeTokenAddress, 
        address _tokenBridgeAddress,
        address _wrappedNativeAddress
    ) {
        SWAP_ROUTER = IUniswapRouter(_swapRouterAddress);
        FEE_TOKEN_ADDRESS = _feeTokenAddress;
        TOKEN_BRIDGE_ADDRESS = _tokenBridgeAddress;
        WRAPPED_NATIVE = _wrappedNativeAddress;
    }

    /// @dev Used to communicate information about executed swaps to UI/user
    event SwapResult(
        address indexed _recipient,
        address _tokenOut,
        address _from,
        uint256 _amountOut,
        uint8 _success
    );

    /// @dev Returns the parsed TokenBridge payload which contains swap 
    /// instructions after redeeming the VAA from the TokenBridge
    function _getParsedPayload(
        bytes calldata encodedVaa,
        uint8 swapFunctionType
    ) private returns (SwapHelper.DecodedVaaParameters memory payload) {
        // complete the transfer on the token bridge
        bytes memory vmPayload = TokenBridge(
            TOKEN_BRIDGE_ADDRESS
        ).completeTransferWithPayload(encodedVaa);

        // parse the payload 
        payload = SwapHelper.decodeVaaPayload(vmPayload);

        // sanity check payload parameters
        require(
            payload.swapFunctionType==swapFunctionType, 
            "incorrect swapFunctionType in payload"
        ); 
    }     

    /// @dev Executes exactIn native asset swap and pays the relayer
    function recvAndSwapExactNativeIn(
        bytes calldata encodedVaa
    ) external returns (uint256 amountOut) {
        // redeem and fetch parsed payload
        SwapHelper.DecodedVaaParameters memory payload =
            _getParsedPayload(
                encodedVaa,
                TypeExactIn
            );  

        // sanity check path 
        require(
            payload.path[0]==FEE_TOKEN_ADDRESS, 
            "tokenIn must be feeToken"
        );
        require(
            payload.path[1]==WRAPPED_NATIVE, 
            "tokenOut must be wrapped Native"
        ); 

        // approve the router to spend tokens 
        TransferHelper.safeApprove(
            payload.path[0], 
            address(SWAP_ROUTER), 
            payload.swapAmount
        );
        
        // set swap options with user params
        ISwapRouter.ExactInputSingleParams memory params =
            ISwapRouter.ExactInputSingleParams({
                tokenIn: payload.path[0],
                tokenOut: payload.path[1],
                fee: payload.poolFee,
                recipient: address(this), 
                deadline: payload.deadline,
                amountIn: payload.swapAmount,
                amountOutMinimum: payload.estimatedAmount,
                sqrtPriceLimitX96: 0
            });

        // try to execute the swap 
        try SWAP_ROUTER.exactInputSingle(params) returns (uint256 amountOut) {
            // calculate how much to pay the relayer in the native token
            uint256 nativeRelayerFee = amountOut * payload.relayerFee / payload.swapAmount;
            uint256 nativeAmountOut = amountOut - nativeRelayerFee;

            // unwrap native and send to recipient 
            IWETH(WRAPPED_NATIVE).withdraw(amountOut);
            payable(payload.recipientAddress).transfer(nativeAmountOut);

            /// pay the relayer in the native token
            payable(msg.sender).transfer(nativeRelayerFee);

            // used in UI to tell user they're getting
            // their desired token
            emit SwapResult(
                payload.recipientAddress, 
                payload.path[1], 
                msg.sender, 
                nativeAmountOut,
                1
            );
            return amountOut;
        } catch {
            // pay relayer in the feeToken since the swap failed
            IERC20 feeToken = IERC20(FEE_TOKEN_ADDRESS); 
            feeToken.safeTransfer(msg.sender, payload.relayerFee);  

            // swap failed - return feeToken (less relayer fees) to recipient
            feeToken.safeTransfer(
                payload.recipientAddress, 
                payload.swapAmount - payload.relayerFee
            );

            // used in UI to tell user they're getting
            // feeToken instead of their desired native asset
            emit SwapResult(
                payload.recipientAddress, 
                payload.path[0], 
                msg.sender, 
                payload.swapAmount - payload.relayerFee,
                0
            );
        }
    }

    /// @dev Executes exactOut native asset swap and pays the relayer
    function recvAndSwapExactNativeOut(
        bytes calldata encodedVaa
    ) external returns (uint256 amountInUsed) {
        // redeem and fetch parsed payload
        SwapHelper.DecodedVaaParameters memory payload =
            _getParsedPayload(
                encodedVaa,
                TypeExactOut
            );

        // sanity check path
        require(
            payload.path[0]==FEE_TOKEN_ADDRESS, 
            "tokenIn must be feeToken"
        );
        require(
            payload.path[1]==WRAPPED_NATIVE, 
            "tokenOut must be wrapped native asset"
        );

        // pay the relayer in feeToken so that user gets desired exact amount out
        IERC20 feeToken = IERC20(FEE_TOKEN_ADDRESS);
        feeToken.safeTransfer(msg.sender, payload.relayerFee);  
        uint256 maxAmountInLessFees = payload.swapAmount - payload.relayerFee;

        // amountOut is the estimated swap amount for exact out methods
        uint256 amountOut = payload.estimatedAmount;

        // approve the router to spend tokens
        TransferHelper.safeApprove(
            payload.path[0], 
            address(SWAP_ROUTER), 
            maxAmountInLessFees
        ); 

        // set swap options with user params
        ISwapRouter.ExactOutputSingleParams memory params =
            ISwapRouter.ExactOutputSingleParams({
                tokenIn: payload.path[0],
                tokenOut: payload.path[1],
                fee: payload.poolFee,
                recipient: address(this), 
                deadline: payload.deadline,
                amountOut: amountOut,
                amountInMaximum: maxAmountInLessFees, 
                sqrtPriceLimitX96: 0
            });

        // try to perform the swap
        try SWAP_ROUTER.exactOutputSingle(params) returns (uint256 amountInUsed) {
            // refund recipient with any feeToken not used in the swap
            if (amountInUsed < maxAmountInLessFees) {
                TransferHelper.safeApprove(
                    FEE_TOKEN_ADDRESS, 
                    address(SWAP_ROUTER), 
                    0
                );
                IERC20(FEE_TOKEN_ADDRESS).safeTransfer(
                    payload.recipientAddress, 
                    maxAmountInLessFees - amountInUsed
                );  
            }

            // unwrap native and send to recipient 
            IWETH(WRAPPED_NATIVE).withdraw(amountOut);
            payable(payload.recipientAddress).transfer(amountOut);

            // used in UI to tell user they're getting
            // their desired native asset
            emit SwapResult(
                payload.recipientAddress, 
                payload.path[1], 
                msg.sender, 
                amountOut,
                1
            );
            return amountInUsed;
        } catch {
            // swap failed - return feeToken to recipient
            IERC20(FEE_TOKEN_ADDRESS).safeTransfer(
                payload.recipientAddress, 
                maxAmountInLessFees
            );

            // used in UI to tell user they're getting
            // feeToken instead of their desired native asset
            emit SwapResult(
                payload.recipientAddress, 
                payload.path[0], 
                msg.sender, 
                maxAmountInLessFees,
                0
            );
        }
    }

    /// @dev Executes exactIn native asset swap
    function _swapExactInBeforeTransfer(
        uint256 amountIn,
        uint256 amountOutMinimum, 
        address contractCaller,
        address[] calldata path,
        uint256 deadline,
        uint24 poolFee
    ) internal returns (uint256 amountOut) {
        // set swap options with user params
        ISwapRouter.ExactInputSingleParams memory params =
            ISwapRouter.ExactInputSingleParams({
                tokenIn: path[0],
                tokenOut: path[1],
                fee: poolFee,
                recipient: address(this),
                deadline: deadline,
                amountIn: amountIn, 
                amountOutMinimum: amountOutMinimum,
                sqrtPriceLimitX96: 0
            });

        // perform the swap
        amountOut = SWAP_ROUTER.exactInputSingle{value: amountIn}(params);
    }

    /// @dev Calls _swapExactInBeforeTransfer and encodes custom payload with 
    /// instructions for executing native asset swaps on the destination chain
    function swapExactNativeInAndTransfer(
        SwapHelper.ExactInParameters calldata swapParams,
        address[] calldata path,
        uint256 relayerFee,
        uint16 targetChainId,
        bytes32 targetContractAddress,
        uint32 nonce
    ) external payable {  
        require(
            swapParams.amountOutMinimum > relayerFee, 
            "insufficient amountOutMinimum to pay relayer"
        );
        require(
            path[0]==WRAPPED_NATIVE, 
            "tokenIn must be wrapped native asset for first swap"
        );
        require(
            path[1]==FEE_TOKEN_ADDRESS, 
            "tokenOut must be feeToken for first swap"
        ); 
        require(msg.value > 0, "must pass non 0 native asset amount");

        // peform the first swap
        uint256 amountOut = _swapExactInBeforeTransfer(
            msg.value,
            swapParams.amountOutMinimum, 
            msg.sender,
            path[0:2], 
            swapParams.deadline,
            swapParams.poolFee
        );

        // create payload with target swap instructions
        bytes memory payload = abi.encodePacked(
            swapParams.targetAmountOutMinimum,
            swapParams.targetChainRecipient,
            path[2],
            path[3],
            swapParams.deadline,
            swapParams.poolFee,
            TypeExactIn,
            relayerFee
        );  

        // approve token bridge to spend feeTokens
        TransferHelper.safeApprove(
            FEE_TOKEN_ADDRESS, 
            TOKEN_BRIDGE_ADDRESS, 
            amountOut
        );

        // send transfer with payload to the TokenBridge
        TokenBridge(TOKEN_BRIDGE_ADDRESS).transferTokensWithPayload(
            FEE_TOKEN_ADDRESS, 
            amountOut, 
            targetChainId, 
            targetContractAddress,  
            nonce, 
            payload
        );
    } 

    /// @dev Executes exactOut native asset swaps
    function _swapExactOutBeforeTransfer(
        uint256 amountOut, 
        uint256 amountInMaximum,
        address contractCaller,
        address[] calldata path,
        uint256 deadline,
        uint24 poolFee
    ) internal {  
        // set swap options with user params
        ISwapRouter.ExactOutputSingleParams memory params =
            ISwapRouter.ExactOutputSingleParams({
                tokenIn: path[0],
                tokenOut: path[1],
                fee: poolFee,
                recipient: address(this),
                deadline: deadline,
                amountOut: amountOut,
                amountInMaximum: amountInMaximum,
                sqrtPriceLimitX96: 0
            });

        // executes the swap returning the amountInUsed 
        // ask for our money back -_- after the swap executes        
        uint256 amountInUsed = SWAP_ROUTER.exactOutputSingle{value: amountInMaximum}(params);
        SWAP_ROUTER.refundETH();

        // return unused native asset to contractCaller
        if (amountInUsed < amountInMaximum) {
            // set SWAP_ROUTER allowance to zero
            TransferHelper.safeApprove(path[0], address(SWAP_ROUTER), 0);
            payable(contractCaller).transfer(
                amountInMaximum - amountInUsed
            );
        }
    }

    /// @dev Calls _swapExactOutBeforeTransfer and encodes custom payload with 
    /// instructions for executing native asset swaps on the destination chain
    function swapExactNativeOutAndTransfer(
        SwapHelper.ExactOutParameters calldata swapParams,
        address[] calldata path,
        uint256 relayerFee,
        uint16 targetChainId,
        bytes32 targetContractAddress,
        uint32 nonce
    ) external payable {  
        require(
            swapParams.amountOut > relayerFee, 
            "insufficient amountOut to pay relayer"
        );
        require(
            path[0]==WRAPPED_NATIVE, 
            "tokenIn must be wrapped native asset for first swap"
        );
        require(
            path[1]==FEE_TOKEN_ADDRESS, 
            "tokenOut must be feeToken for first swap"
        );
        require(msg.value > 0, "must pass non 0 native asset amount");

        // peform the first swap
        _swapExactOutBeforeTransfer(
            swapParams.amountOut, 
            msg.value, 
            msg.sender,
            path[0:2], 
            swapParams.deadline,
            swapParams.poolFee
        );

        // create payload with target swap instructions
        bytes memory payload = abi.encodePacked(
            swapParams.targetAmountOut,
            swapParams.targetChainRecipient,
            path[2],
            path[3],
            swapParams.deadline,
            swapParams.poolFee,
            TypeExactOut,
            relayerFee
        );  

        // approve token bridge to spend feeTokens 
        TransferHelper.safeApprove(
            FEE_TOKEN_ADDRESS, 
            TOKEN_BRIDGE_ADDRESS, 
            swapParams.amountOut
        );

        // send transfer with payload to the TokenBridge
        TokenBridge(TOKEN_BRIDGE_ADDRESS).transferTokensWithPayload(
            FEE_TOKEN_ADDRESS, 
            swapParams.amountOut, 
            targetChainId, 
            targetContractAddress, 
            nonce, 
            payload
        );
    }

    // necessary for receiving native assets 
    receive() external payable {}
}