_routerAddress

_slipStreamAddress

_path

_amountIn

_amountOut

execute

executeRoutes

factoryAerodrome

getRoutes

from

stable

factory

owner

router

slipStream

slipstreamSwap

amountOut

_amountOutMin

_routes

swapETHForTokens

amounts

swapTokensForTokens

_token

withdraw

// SPDX-License-Identifier: GPL-3.0

// BasicSwap V2

/*
* Variety of functions which interact with Aerodrome's Router contract.
* Many of these functions produce the same end result (a token swap) but with a different swapping philosophy
* Most of these are tests of features and variations in logic before incorporating into more sophisticated bots
* Welcome job recruiters!! This contract is mainly a demo of my skills, please reach out for further questions.
*/

pragma solidity ^0.8.19;

import 'hardhat/console.sol';
import "./Router.sol";
import { TransferHelper } from '@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol';
import { ISwapRouter } from './contracts/periphery/interfaces/ISwapRouter.sol';

contract BasicSwap {
    IRouter public router;
    ISwapRouter public slipStream;
    address public factoryAerodrome = 0x420DD381b31aEf6683db6B902084cB0FFECe40Da;
    address public owner;

    constructor(address _routerAddress, address _slipStreamAddress) {
        router = IRouter(_routerAddress);
        slipStream = ISwapRouter(_slipStreamAddress);
        owner = msg.sender;
    }

    /*
    * 1.)
    * @notice ETH to Tokens of your choice. Straight forward... classic swap
    * @dev Calls the swapExactETHForTokens function on an external router contract.
    * The ETH value to be swapped should be sent along with the transaction. 
    * i.e. { value : amountIn } obviously in Wei
    * The function sets a 1-hour deadline for the swap to be executed.
    * 
    * @param _amountOutMin The minimum amount of tokens expected to receive from the swap.
    * @param _routes An array of routes specifying the path of token swaps.
    * Each route consists of the token to be swapped and the corresponding pair contract.
    * @param _to The address to send the swapped tokens to.
    * 
    * @return amounts An array of output amounts for each token in the swap path.
    */
    function swapETHForTokens(
        uint256 _amountOutMin, 
        IRouter.Route[] calldata _routes, 
        address _to) 
    external payable returns (uint256[] memory amounts) {
        // Call the swapExactETHForTokens function on the external router contract
        router.swapExactETHForTokens{value: msg.value}(
            _amountOutMin, 
            _routes, 
            _to, 
            block.timestamp + 3600
        );

        return amounts;
    }

    /*
    * 2.)
    * @notice Tokens to Tokens. ERC20. The good stuff
    * @dev Calls the swapExactTokensForTokens function on an external router contract.
    * Function sets a 1-hour deadline for the swap to be executed.
    * 
    * @param _amountIn is the amount of tokenA you want to swap for tokenB
    * @param _amountOutMin The minimum amount of tokens expected to receive from the swap.
    * @param _routes An array of routes specifying the path of token swaps.
    * Each route consists of the token to be swapped and the corresponding pair contract.
    * In javascript this is usually an object array if you're interacting via ethers or web3.js
    * @param _to The address to send the swapped tokens to.
    * 
    * @return amounts An array of output amounts for each token in the swap path.
    */
    function swapTokensForTokens(
        uint256 _amountIn,
        uint256 _amountOutMin, 
        IRouter.Route[] calldata _routes, 

        address _to) 
    external returns (uint256[] memory amounts) {

        TransferHelper.safeTransferFrom(_routes[0].from, msg.sender, address(this), _amountIn);

        TransferHelper.safeApprove(_routes[0].from, address(router), _amountIn);

        // Call the swapExactTokensForTokens function on the external router contract
        router.swapExactTokensForTokens(
            _amountIn,
            _amountOutMin, 
            _routes, 
            _to, 
            block.timestamp + 3600
        );

        return amounts;
    }

    /*
    * 3.)
    * @notice Get an array of Route structs by submitting a 2 array path of token addresses
    * @dev Creates an array of Route structs from Aerodrome's IRouter.sol
    * 
    * @param _path is a two unit array of token addresses
    * 
    * @return routes which is a proper array of Route structs you can then use for swapping
    */
    function getRoutes(
        address[] memory _path
    ) external view returns (IRouter.Route[] memory){

        IRouter.Route[] memory routes = new IRouter.Route[](1);
        routes[0] = IRouter.Route({
            from: _path[0],
            to: _path[1],
            stable: false,
            factory: factoryAerodrome
        });

        return routes;
    }

    // 4. Integrated logic for developing the Routes from an array of token addresses. Then performing the swap
    /*
    * 4.)
    * @notice Integrated logic for developing the Routes from an array of token addresses. Then performing the swap
    * @dev Calls the swapExactTokensForTokens function on an external router contract.
    * Function sets a 20-minute deadline for the swap to be executed.
    * 
    * @param _path is a two unit array of token addresses
    * @param _amountIn is the amount of tokenA you want to swap for tokenB
    * @param _amountOut The minimum amount of tokens expected to receive from the swap.
    * 
    * !!! IMPORTANT !!!
    * @return amounts An array of output amounts to THIS CONTRACT. This is for local testing only
    */
    function execute(
        address[] memory _path,
        uint256 _amountIn,
        uint256 _amountOut
    ) external {
        TransferHelper.safeTransferFrom(_path[0], msg.sender, address(this), _amountIn);
        TransferHelper.safeApprove(_path[0], address(router), _amountIn);

        IRouter.Route[] memory routes = new IRouter.Route[](1);
        routes[0] = IRouter.Route({
            from: _path[0],
            to: _path[1],
            stable: false,
            factory: factoryAerodrome
        });


        // Call the swapExactTokensForTokens function on the external router contract
        router.swapExactTokensForTokens(
            _amountIn,
            _amountOut, 
            routes,
            address(this), 
            block.timestamp + 1200
        );
    }
 
    /*
    * 5a.)
    * @notice Internal function for getting Route struct from path. Internal/External call pattern
    * @dev Calls the swapExactTokensForTokens function on an external router contract.
    * Function sets a 20-minute deadline for the swap to be executed.
    * 
    * @param _path is a two unit array of token addresses
    * 
    * @return routes struct to be used in swap for external contract call
    */
    function _getRoutes(
        address[] memory _path
    ) internal view returns (IRouter.Route[] memory){

        IRouter.Route[] memory routes = new IRouter.Route[](1);
        routes[0] = IRouter.Route({
            from: _path[0],
            to: _path[1],
            stable: false,
            factory: 0x420DD381b31aEf6683db6B902084cB0FFECe40Da
        });

        return routes;
    }

    /*
    * 5b.)
    * @notice External function for performing a swap. Calls the internal function for getRoutes
    * @dev Calls the swapExactTokensForTokens function on an external router contract.
    * Function sets a 20-minute deadline for the swap to be executed.
    * 
    * @param _path is a two unit array of token addresses
    * @param _amountIn is the amount of tokenA you want to swap for tokenB
    * @param _amountOut The minimum amount of tokens expected to receive from the swap.
    * 
    * !!! IMPORTANT !!!
    * @return amounts An array of output amounts to THIS CONTRACT. This is for local testing only
    */
    function executeRoutes(
        address[] memory _path,
        uint256 _amountIn,
        uint256 _amountOut        
    ) external {
        require(_path.length == 2, "Path must have two elements");
        TransferHelper.safeTransferFrom(_path[0], msg.sender, address(this), _amountIn);
        TransferHelper.safeApprove(_path[0], address(router), _amountIn);
    
        IRouter.Route[] memory _routes = _getRoutes(_path);

        // Call the swapExactTokensForTokens function on the external router contract
        router.swapExactTokensForTokens(
            _amountIn,
            _amountOut,
            _routes,
            address(this), 
            block.timestamp + 1200
        );
    }

    /*
    * 5b.)
    * @notice Simple withdrawl pattern for tokens which may be sent to the contract
    * @dev Owner calls the withdraw function on an external router contract.
    * 
    * @param _token is the address of the token you want to extract from the contract
    * 
    * Not the best logical method for reciving tokens during a swap, but writing the contract
    * in this manner to demonstrate functionality and how an action like this may be done.
    */
    function withdraw(address _token) external {
        require(msg.sender == owner, "Owner must call this function. Funds returned to owner only");
        IERC20(_token).transfer(owner, IERC20(_token).balanceOf(address(this)));
    }

    function slipstreamSwap(
        address[] memory _path,
        uint256 _amountIn,
        uint256 _amountOut
    ) external payable returns (uint256 amountOut) {

        TransferHelper.safeTransferFrom(_path[0], msg.sender, address(this), _amountIn);
        TransferHelper.safeApprove(_path[0], address(slipStream), _amountIn);

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
            tokenIn: _path[0],
            tokenOut: _path[1],
            tickSpacing: 200,
            recipient: address(this),
            deadline: block.timestamp + 1200,
            amountIn: _amountIn,
            amountOutMinimum: _amountOut,
            sqrtPriceLimitX96: 0
        });

        console.log("Calling exactInputSingle with params");
        amountOut = slipStream.exactInputSingle(params);
        console.log("Swap result amountOut:", amountOut);
        return amountOut;
    }
}
 

amount0Delta

amount1Delta

data

uniswapV3SwapCallback

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Callback for ICLPoolActions#swap
/// @notice Any contract that calls ICLPoolActions#swap must implement this interface
interface ICLSwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via ICLPool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a CLPool deployed by the canonical CLFactory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the ICLPoolActions#swap call
    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;
}


Callback for ICLPoolActions#swap

params

exactInput

exactInputSingle

exactOutput

amountIn

exactOutputSingle

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import "../../core/interfaces/callback/ICLSwapCallback.sol";

/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via CL
interface ISwapRouter is ICLSwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        int24 tickSpacing;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        int24 tickSpacing;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}


Router token swapping functionality

spender

allowance

value

approve

account

balanceOf

totalSupply

transfer

transferFrom

Approval

Transfer

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}


// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}


The `BasicSwap` contract facilitates various token swap operations using Aerodrome's Router and Uniswap's SlipStream. It supports ETH-to-token and token-to-token swaps, constructs swap routes, and executes swaps with specified parameters. The contract also includes functions for withdrawing tokens and performing swaps via Uniswap's SlipStream. It is designed for testing and demonstrating different swapping strategies.