Dex223PoolLib.sol

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.7.6;
pragma abicoder v2;

import './interfaces/callback/IUniswapV3MintCallback.sol';
import './interfaces/pool/IUniswapV3PoolEvents.sol';
import './interfaces/IERC20Minimal.sol';
import './interfaces/callback/IUniswapV3SwapCallback.sol';
import './interfaces/ITokenConverter.sol';
import './interfaces/IUniswapV3Pool.sol';

import './libraries/SqrtPriceMath.sol';
import './libraries/Position.sol';
import './libraries/LowGasSafeMath.sol';
import './libraries/SafeCast.sol';
import './libraries/Tick.sol';
import './libraries/TickBitmap.sol';
import './libraries/Oracle.sol';
import './libraries/TransferHelper.sol';
import './libraries/SwapMath.sol';

contract Dex223PoolLib {
    using LowGasSafeMath for uint256;
    using LowGasSafeMath for int256;
    using SafeCast for uint256;
    using SafeCast for int256;
    using Tick for mapping(int24 => Tick.Info);
    using TickBitmap for mapping(int16 => uint256);
    using Position for mapping(bytes32 => Position.Info);
    using Position for Position.Info;
    using Oracle for Oracle.Observation[65535];

    struct Token
    {
        address erc20;
        address erc223;
    }

    address public factory;

    ITokenStandardConverter public converter;

    Token public token0;
    Token public token1;

    uint24 public  fee;

    int24 public  tickSpacing;

    uint128 public  maxLiquidityPerTick;

    struct Slot0 {
        // the current price
        uint160 sqrtPriceX96;
        // the current tick
        int24 tick;
        // the most-recently updated index of the observations array
        uint16 observationIndex;
        // the current maximum number of observations that are being stored
        uint16 observationCardinality;
        // the next maximum number of observations to store, triggered in observations.write
        uint16 observationCardinalityNext;
        // the current protocol fee as a percentage of the swap fee taken on withdrawal
        // represented as an integer denominator (1/x)%
        uint8 feeProtocol;
        // whether the pool is locked
        bool unlocked;
    }
    Slot0 public  slot0;

    uint256 public  feeGrowthGlobal0X128;
    uint256 public  feeGrowthGlobal1X128;

    // accumulated protocol fees in token0/token1 units
    struct ProtocolFees {
        uint128 token0;
        uint128 token1;
    }

    address public swap_sender;
    mapping(address => mapping(address => uint)) internal erc223deposit;    // user => token => value


    ProtocolFees public  protocolFees;

    uint128 public  liquidity;

    mapping(int24 => Tick.Info) public  ticks;
    mapping(int16 => uint256) public  tickBitmap;
    mapping(bytes32 => Position.Info) public  positions;
    Oracle.Observation[65535] public  observations;

    struct ModifyPositionParams {
        // the address that owns the position
        address owner;
        // the lower and upper tick of the position
        int24 tickLower;
        int24 tickUpper;
        // any change in liquidity
        int128 liquidityDelta;
    }


     event Mint(
        address sender,
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

      event Burn(
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

    event Collect(
        address indexed owner,
        address recipient,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount0,
        uint128 amount1
    );

      event Swap(
        address indexed sender,
        address indexed recipient,
        int256 amount0,
        int256 amount1,
        uint160 sqrtPriceX96,
        uint128 liquidity,
        int24 tick
    );

    /// @dev Common checks for valid tick inputs.
    function checkTicks(int24 tickLower, int24 tickUpper) private pure {
        require(tickLower < tickUpper, 'TLU');
        require(tickLower >= TickMath.MIN_TICK, 'TLM');
        require(tickUpper <= TickMath.MAX_TICK, 'TUM');
    }

    /// @dev Returns the block timestamp truncated to 32 bits, i.e. mod 2**32. This method is overridden in tests.
//    function _blockTimestamp() internal view virtual returns (uint32) {
//        return uint32(block.timestamp); // truncation is desired
//    }

    /// @dev Get the pool's balance of token0
    /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize
    /// check
    function balance0() private view returns (uint256) {
        (bool success20, bytes memory data20) =
                                token0.erc20.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
        (bool success223, bytes memory data223) =
                                token0.erc223.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
        uint256 _balance;
        if(success20 && data20.length >= 32)  _balance += abi.decode(data20, (uint256));
        if(success223 && data223.length >= 32) _balance += abi.decode(data223, (uint256));
        require((success20 && data20.length >= 32) || (success223 && data223.length >= 32));
        return _balance;
    }

    /// @dev Get the pool's balance of token1
    /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize
    /// check
    function balance1() private view returns (uint256) {
        (bool success20, bytes memory data20) =
                                token1.erc20.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
        (bool success223, bytes memory data223) =
                                token1.erc223.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
        uint256 _balance;
        if(success20 && data20.length >= 32)  _balance += abi.decode(data20, (uint256));
        if(success223 && data223.length >= 32) _balance += abi.decode(data223, (uint256));
        require((success20 && data20.length >= 32) || (success223 && data223.length >= 32));
        return _balance;
    }

    /// @dev Gets and updates a position with the given liquidity delta
    /// @param owner the owner of the position
    /// @param tickLower the lower tick of the position's tick range
    /// @param tickUpper the upper tick of the position's tick range
    /// @param tick the current tick, passed to avoid sloads
    function _updatePosition(
        address owner,
        int24 tickLower,
        int24 tickUpper,
        int128 liquidityDelta,
        int24 tick
    ) private returns (Position.Info storage position) {
        position = positions.get(owner, tickLower, tickUpper);

        uint256 _feeGrowthGlobal0X128 = feeGrowthGlobal0X128; // SLOAD for gas optimization
        uint256 _feeGrowthGlobal1X128 = feeGrowthGlobal1X128; // SLOAD for gas optimization

        // if we need to update the ticks, do it
        bool flippedLower;
        bool flippedUpper;
        if (liquidityDelta != 0) {
            uint32 time = uint32(block.timestamp);
            (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =
                                observations.observeSingle(
                    time,
                    0,
                    slot0.tick,
                    slot0.observationIndex,
                    liquidity,
                    slot0.observationCardinality
                );

            flippedLower = ticks.update(
                tickLower,
                tick,
                liquidityDelta,
                _feeGrowthGlobal0X128,
                _feeGrowthGlobal1X128,
                secondsPerLiquidityCumulativeX128,
                tickCumulative,
                time,
                false,
                maxLiquidityPerTick
            );
            flippedUpper = ticks.update(
                tickUpper,
                tick,
                liquidityDelta,
                _feeGrowthGlobal0X128,
                _feeGrowthGlobal1X128,
                secondsPerLiquidityCumulativeX128,
                tickCumulative,
                time,
                true,
                maxLiquidityPerTick
            );

            if (flippedLower) {
                tickBitmap.flipTick(tickLower, tickSpacing);
            }
            if (flippedUpper) {
                tickBitmap.flipTick(tickUpper, tickSpacing);
            }
        }

        (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
                            ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);

        position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);

        // clear any tick data that is no longer needed
        if (liquidityDelta < 0) {
            if (flippedLower) {
                ticks.clear(tickLower);
            }
            if (flippedUpper) {
                ticks.clear(tickUpper);
            }
        }
    }

    /// @dev Effect some changes to a position
    /// @param params the position details and the change to the position's liquidity to effect
    /// @return position a storage pointer referencing the position with the given owner and tick range
    /// @return amount0 the amount of token0 owed to the pool, negative if the pool should pay the recipient
    /// @return amount1 the amount of token1 owed to the pool, negative if the pool should pay the recipient
    function _modifyPosition(ModifyPositionParams memory params)
    private
    returns (
        Position.Info storage position,
        int256 amount0,
        int256 amount1
    )
    {
        checkTicks(params.tickLower, params.tickUpper);

        Slot0 memory _slot0 = slot0; // SLOAD for gas optimization

        position = _updatePosition(
            params.owner,
            params.tickLower,
            params.tickUpper,
            params.liquidityDelta,
            _slot0.tick
        );

        if (params.liquidityDelta != 0) {
            if (_slot0.tick < params.tickLower) {
                // current tick is below the passed range; liquidity can only become in range by crossing from left to
                // right, when we'll need _more_ token0 (it's becoming more valuable) so user must provide it
                amount0 = SqrtPriceMath.getAmount0Delta(
                    TickMath.getSqrtRatioAtTick(params.tickLower),
                    TickMath.getSqrtRatioAtTick(params.tickUpper),
                    params.liquidityDelta
                );
            } else if (_slot0.tick < params.tickUpper) {
                // current tick is inside the passed range
                uint128 liquidityBefore = liquidity; // SLOAD for gas optimization

                // write an oracle entry
                (slot0.observationIndex, slot0.observationCardinality) = observations.write(
                    _slot0.observationIndex,
                    uint32(block.timestamp),
                    _slot0.tick,
                    liquidityBefore,
                    _slot0.observationCardinality,
                    _slot0.observationCardinalityNext
                );

                amount0 = SqrtPriceMath.getAmount0Delta(
                    _slot0.sqrtPriceX96,
                    TickMath.getSqrtRatioAtTick(params.tickUpper),
                    params.liquidityDelta
                );
                amount1 = SqrtPriceMath.getAmount1Delta(
                    TickMath.getSqrtRatioAtTick(params.tickLower),
                    _slot0.sqrtPriceX96,
                    params.liquidityDelta
                );

                liquidity = LiquidityMath.addDelta(liquidityBefore, params.liquidityDelta);
            } else {
                // current tick is above the passed range; liquidity can only become in range by crossing from right to
                // left, when we'll need _more_ token1 (it's becoming more valuable) so user must provide it
                amount1 = SqrtPriceMath.getAmount1Delta(
                    TickMath.getSqrtRatioAtTick(params.tickLower),
                    TickMath.getSqrtRatioAtTick(params.tickUpper),
                    params.liquidityDelta
                );
            }
        }
    }

    /// @dev noDelegateCall is applied indirectly via _modifyPosition
    function mint(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount,
        bytes calldata data
    ) external  /*adjustableSender*/ returns (uint256 amount0, uint256 amount1) {
        require(amount > 0);
        (, int256 amount0Int, int256 amount1Int) =
                        _modifyPosition(
                ModifyPositionParams({
                    owner: recipient,
                    tickLower: tickLower,
                    tickUpper: tickUpper,
                    liquidityDelta: int256(amount).toInt128()
                })
            );

        amount0 = uint256(amount0Int);
        amount1 = uint256(amount1Int);

        uint256 balance0Before;
        uint256 balance1Before;
        if (amount0 > 0) balance0Before = balance0();
        if (amount1 > 0) balance1Before = balance1();
        IUniswapV3MintCallback(msg.sender).uniswapV3MintCallback(amount0, amount1, data);
        if (amount0 > 0) require(balance0Before.add(amount0) <= balance0(), 'M0');
        if (amount1 > 0) require(balance1Before.add(amount1) <= balance1(), 'M1');

        emit Mint(msg.sender, recipient, tickLower, tickUpper, amount, amount0, amount1);
    }

    function optimisticDelivery(address _token, address _recipient, uint256 _amount) internal
    {
        bool _is223 = false;
        if(_token == token0.erc223 || _token == token1.erc223) _is223 = true;
        // Transfer the tokens and hope that the transfer will succeed i.e. there were
        // enough tokens of the given standard to cover the cost of the transfer.
        (bool success, bytes memory data) =
                            _token.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, _recipient, _amount));

        //require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
        if(!success)
        {
            if(_is223)
            {
                IERC20Minimal(_token).transfer(address(converter), _amount - IERC20Minimal(_token).balanceOf(address(this)));
            }
            else
            {
                // Approve the converter first if necessary.
                // This approval is expected to execute once and forever.
                if(IERC20Minimal(_token).allowance(address(this), address(converter)) < _amount)
                {
                    IERC20Minimal(_token).approve(address(converter), 2**256-1);
                }
                converter.convertERC20(_token, _amount - IERC20Minimal(_token).balanceOf(address(this)));
            }
            TransferHelper.safeTransfer(_token, _recipient, _amount);
        }
    }

    function collect(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount0Requested,
        uint128 amount1Requested,
        bool token0_223,
        bool token1_223
    ) external returns (uint128 amount0, uint128 amount1) {
        // we don't need to checkTicks here, because invalid positions will never have non-zero tokensOwed{0,1}
        Position.Info storage position = positions.get(msg.sender, tickLower, tickUpper);

        amount0 = amount0Requested > position.tokensOwed0 ? position.tokensOwed0 : amount0Requested;
        amount1 = amount1Requested > position.tokensOwed1 ? position.tokensOwed1 : amount1Requested;

        if (amount0 > 0) {
            position.tokensOwed0 -= amount0;
            //TransferHelper.safeTransfer(token0.erc20, recipient, amount0);
            if(token0_223) optimisticDelivery(token0.erc223, recipient, amount0);
            else optimisticDelivery(token0.erc20, recipient, amount0);
        }
        if (amount1 > 0) {
            position.tokensOwed1 -= amount1;
            //TransferHelper.safeTransfer(token1.erc20, recipient, amount1);
            if(token1_223) optimisticDelivery(token1.erc223, recipient, amount1);
            else optimisticDelivery(token1.erc20, recipient, amount1);
        }

        emit Collect(msg.sender, recipient, tickLower, tickUpper, amount0, amount1);
    }

    /// @dev noDelegateCall is applied indirectly via _modifyPosition
    function burn(
        int24 tickLower,
        int24 tickUpper,
        uint128 amount
    ) external  returns (uint256 amount0, uint256 amount1) {
        (Position.Info storage position, int256 amount0Int, int256 amount1Int) =
                        _modifyPosition(
                ModifyPositionParams({
                    owner: msg.sender,
                    tickLower: tickLower,
                    tickUpper: tickUpper,
                    liquidityDelta: -int256(amount).toInt128()
                })
            );

        amount0 = uint256(-amount0Int);
        amount1 = uint256(-amount1Int);

        if (amount0 > 0 || amount1 > 0) {
            (position.tokensOwed0, position.tokensOwed1) = (
                position.tokensOwed0 + uint128(amount0),
                position.tokensOwed1 + uint128(amount1)
            );
        }

        emit Burn(msg.sender, tickLower, tickUpper, amount, amount0, amount1);
    }


    struct SwapCache {
        // the protocol fee for the input token
        uint8 feeProtocol;
        // liquidity at the beginning of the swap
        uint128 liquidityStart;
        // the timestamp of the current block
        uint32 blockTimestamp;
        // the current value of the tick accumulator, computed only if we cross an initialized tick
        int56 tickCumulative;
        // the current value of seconds per liquidity accumulator, computed only if we cross an initialized tick
        uint160 secondsPerLiquidityCumulativeX128;
        // whether we've computed and cached the above two accumulators
        bool computedLatestObservation;
    }

    // the top level state of the swap, the results of which are recorded in storage at the end
    struct SwapState {
        // the amount remaining to be swapped in/out of the input/output asset
        int256 amountSpecifiedRemaining;
        // the amount already swapped out/in of the output/input asset
        int256 amountCalculated;
        // current sqrt(price)
        uint160 sqrtPriceX96;
        // the tick associated with the current price
        int24 tick;
        // the global fee growth of the input token
        uint256 feeGrowthGlobalX128;
        // amount of input token paid as protocol fee
        uint128 protocolFee;
        // the current liquidity in range
        uint128 liquidity;
    }

    struct StepComputations {
        // the price at the beginning of the step
        uint160 sqrtPriceStartX96;
        // the next tick to swap to from the current tick in the swap direction
        int24 tickNext;
        // whether tickNext is initialized or not
        bool initialized;
        // sqrt(price) for the next tick (1/0)
        uint160 sqrtPriceNextX96;
        // how much is being swapped in in this step
        uint256 amountIn;
        // how much is being swapped out
        uint256 amountOut;
        // how much fee is being paid in
        uint256 feeAmount;
    }

    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bool prefer223Out,
        bytes memory data
    ) external /*noDelegateCall*/ // noDelegateCall will not prevent delegatecalling
                                                        // this method from the same contract via `tokenReceived` of ERC-223
     returns (int256 amount0, int256 amount1) {

        require(amountSpecified != 0, 'AS');

        Slot0 memory slot0Start = slot0;

        require(slot0Start.unlocked, 'LOK');
        require(
            zeroForOne
                ? sqrtPriceLimitX96 < slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO
                : sqrtPriceLimitX96 > slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO,
            'SPL'
        );

        slot0.unlocked = false;

        SwapCache memory cache =
            SwapCache({
                liquidityStart: liquidity,
                blockTimestamp: uint32(block.timestamp),
                feeProtocol: zeroForOne ? (slot0Start.feeProtocol % 16) : (slot0Start.feeProtocol >> 4),
                secondsPerLiquidityCumulativeX128: 0,
                tickCumulative: 0,
                computedLatestObservation: false
            });

        bool exactInput = amountSpecified > 0;

        SwapState memory state =
            SwapState({
                amountSpecifiedRemaining: amountSpecified,
                amountCalculated: 0,
                sqrtPriceX96: slot0Start.sqrtPriceX96,
                tick: slot0Start.tick,
                feeGrowthGlobalX128: zeroForOne ? feeGrowthGlobal0X128 : feeGrowthGlobal1X128,
                protocolFee: 0,
                liquidity: cache.liquidityStart
            });

        // continue swapping as long as we haven't used the entire input/output and haven't reached the price limit
        while (state.amountSpecifiedRemaining != 0 && state.sqrtPriceX96 != sqrtPriceLimitX96) {
            StepComputations memory step;

            step.sqrtPriceStartX96 = state.sqrtPriceX96;

            (step.tickNext, step.initialized) = tickBitmap.nextInitializedTickWithinOneWord(
                state.tick,
                tickSpacing,
                zeroForOne
            );

            // ensure that we do not overshoot the min/max tick, as the tick bitmap is not aware of these bounds
            if (step.tickNext < TickMath.MIN_TICK) {
                step.tickNext = TickMath.MIN_TICK;
            } else if (step.tickNext > TickMath.MAX_TICK) {
                step.tickNext = TickMath.MAX_TICK;
            }

            // get the price for the next tick
            step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);

            // compute values to swap to the target tick, price limit, or point where input/output amount is exhausted
            (state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount) = SwapMath.computeSwapStep(
                state.sqrtPriceX96,
                (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96)
                    ? sqrtPriceLimitX96
                    : step.sqrtPriceNextX96,
                state.liquidity,
                state.amountSpecifiedRemaining,
                fee
            );

            if (exactInput) {
                state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
                state.amountCalculated = state.amountCalculated.sub(step.amountOut.toInt256());
            } else {
                state.amountSpecifiedRemaining += step.amountOut.toInt256();
                state.amountCalculated = state.amountCalculated.add((step.amountIn + step.feeAmount).toInt256());
            }

            // if the protocol fee is on, calculate how much is owed, decrement feeAmount, and increment protocolFee
            if (cache.feeProtocol > 0) {
                uint256 delta = step.feeAmount / cache.feeProtocol;
                step.feeAmount -= delta;
                state.protocolFee += uint128(delta);
            }

            // update global fee tracker
            if (state.liquidity > 0)
                state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);

            // shift tick if we reached the next price
            if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
                // if the tick is initialized, run the tick transition
                if (step.initialized) {
                    // check for the placeholder value, which we replace with the actual value the first time the swap
                    // crosses an initialized tick
                    if (!cache.computedLatestObservation) {
                        (cache.tickCumulative, cache.secondsPerLiquidityCumulativeX128) = observations.observeSingle(
                            cache.blockTimestamp,
                            0,
                            slot0Start.tick,
                            slot0Start.observationIndex,
                            cache.liquidityStart,
                            slot0Start.observationCardinality
                        );
                        cache.computedLatestObservation = true;
                    }
                    int128 liquidityNet =
                        ticks.cross(
                            step.tickNext,
                            (zeroForOne ? state.feeGrowthGlobalX128 : feeGrowthGlobal0X128),
                            (zeroForOne ? feeGrowthGlobal1X128 : state.feeGrowthGlobalX128),
                            cache.secondsPerLiquidityCumulativeX128,
                            cache.tickCumulative,
                            cache.blockTimestamp
                        );
                    // if we're moving leftward, we interpret liquidityNet as the opposite sign
                    // safe because liquidityNet cannot be type(int128).min
                    if (zeroForOne) liquidityNet = -liquidityNet;

                    state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
                }

                state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
            } else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
                // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
                state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
            }
        }

        // update tick and write an oracle entry if the tick change
        if (state.tick != slot0Start.tick) {
            (uint16 observationIndex, uint16 observationCardinality) =
                observations.write(
                    slot0Start.observationIndex,
                    cache.blockTimestamp,
                    slot0Start.tick,
                    cache.liquidityStart,
                    slot0Start.observationCardinality,
                    slot0Start.observationCardinalityNext
                );
            (slot0.sqrtPriceX96, slot0.tick, slot0.observationIndex, slot0.observationCardinality) = (
                state.sqrtPriceX96,
                state.tick,
                observationIndex,
                observationCardinality
            );
        } else {
            // otherwise just update the price
            slot0.sqrtPriceX96 = state.sqrtPriceX96;
        }

        // update liquidity if it changed
        if (cache.liquidityStart != state.liquidity) liquidity = state.liquidity;

        // update fee growth global and, if necessary, protocol fees
        // overflow is acceptable, protocol has to withdraw before it hits type(uint128).max fees
        if (zeroForOne) {
            feeGrowthGlobal0X128 = state.feeGrowthGlobalX128;
            if (state.protocolFee > 0) protocolFees.token0 += state.protocolFee;
        } else {
            feeGrowthGlobal1X128 = state.feeGrowthGlobalX128;
            if (state.protocolFee > 0) protocolFees.token1 += state.protocolFee;
        }

        (amount0, amount1) = zeroForOne == exactInput
            ? (amountSpecified - state.amountSpecifiedRemaining, state.amountCalculated)
            : (state.amountCalculated, amountSpecified - state.amountSpecifiedRemaining);

        // do the transfers and collect payment
        // @Dexaran: Adjusting the token delivery method for ERC-20 and ERC-223 tokens
        //           in case of ERC-223 this `swap()` func is called within `tokenReceived()` invocation
        //           so the ERC-223 tokens are already in the contract
        //           and the amount is stored in the `erc223deposit[msg.sender][token]` variable.
        if (zeroForOne) {

            // SECURITY WARNING!
            // In order to prevent re-entrancy attacks
            // first subtract the deposited amount or pull the tokens from the swap sender
            // then deliver the swapped amount.

            // ERC-223 depositing logic
            if (erc223deposit[swap_sender][token0.erc223] >= uint256(amount0))
            {
                erc223deposit[swap_sender][token0.erc223] -= uint256(amount0);
            }
            // ERC-20 depositing logic
            else
            {
                uint256 balance0Before = balance0();
                IUniswapV3SwapCallback(swap_sender).uniswapV3SwapCallback(amount0, amount1, data);
                require(balance0Before.add(uint256(amount0)) <= balance0(), 'IIA');
            }

            if (amount1 < 0)
            {
                if(prefer223Out)
                {
                    // Optimistically attempt to transfer the full amount of tokens to the recipient.
                    // Optimizes gas usages for situations where there are enough tokens in the pool
                    // to provide the recipient with the tokens of the chosen standard
                    // without a need to convert them via ERC-7417.
                    (bool success, bytes memory data) =
                        token1.erc223.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, recipient, uint256(-amount1)));

                        //require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
                    if(!success)
                    {
                        // The transfer didn't work and it could be because there are not enough tokens in the contract
                        // to pay in the selected standard.
                        // We need to call the converter and transform part of the tokens from pools balance
                        // to the tokens of desired standard.

                        if(IERC20Minimal(token1.erc223).balanceOf(address(this)) < uint256(-amount1))
                        {
                            IERC20Minimal(token1.erc223).transfer(address(converter), uint256(-amount1) - IERC20Minimal(token1.erc223).balanceOf(address(this)));
                        }
                        // Now there should be enough tokens to cover the payment.
                        TransferHelper.safeTransfer(token1.erc223, recipient, uint256(-amount1));
                    }
                }
                else
                {
                    // Optimistically attempt to transfer the full amount of tokens to the recipient.
                    (bool success, bytes memory data) =
                        token1.erc20.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, recipient, uint256(-amount1)));

                        //require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
                    if(!success)
                    {
                        // Not enough ERC-20 tokens on the pools balance
                        // Need to convert ERC-223 version to ERC-20 then deliver it to the user.

                        if(IERC20Minimal(token1.erc20).balanceOf(address(this)) < uint256(-amount1))
                        {
                            // Approve the converter first if necessary.
                            // This approval is expected to execute once and forever.
                            if(IERC20Minimal(token1.erc20).allowance(address(this), address(converter)) < uint256(-amount1))
                            {
                                IERC20Minimal(token1.erc20).approve(address(converter), 2**256-1);
                            }
                            converter.convertERC20(token1.erc20, uint256(-amount1) - IERC20Minimal(token1.erc20).balanceOf(address(this)));
                        }
                        // Now there should be enough tokens to cover the payment.
                        TransferHelper.safeTransfer(token1.erc20, recipient, uint256(-amount1));
                    }
                }
            }
        } else {

            // Again, first receive the payment, then deliver the tokens.
            // We don't want to be hacked as TheDAO was.

            // ERC-223 depositing logic
            if (erc223deposit[swap_sender][token1.erc223] >= uint256(amount1))
            {
                erc223deposit[swap_sender][token1.erc223] -= uint256(amount1);
            }
            // ERC-20 depositing logic
            else
            {
                uint256 balance1Before = balance1();
                IUniswapV3SwapCallback(swap_sender).uniswapV3SwapCallback(amount0, amount1, data);
                require(balance1Before.add(uint256(amount1)) <= balance1(), 'IIA');
            }


            //if (amount0 < 0) TransferHelper.safeTransfer(token0.erc20, recipient, uint256(-amount0));


            if(prefer223Out)
                {
                    // Optimistically attempt to transfer the full amount of tokens to the recipient.
                    // Optimizes gas usages for situations where there are enough tokens in the pool
                    // to provide the recipient with the tokens of the chosen standard
                    // without a need to convert them via ERC-7417.
                    (bool success, bytes memory data) =
                        token0.erc223.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, recipient, uint256(-amount0)));

                        //require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
                    if(!success)
                    {
                        // The transfer didn't work and it could be because there are not enough tokens in the contract
                        // to pay in the selected standard.
                        // We need to call the converter and transform part of the tokens from pools balance
                        // to the tokens of desired standard.

                        if(IERC20Minimal(token0.erc223).balanceOf(address(this)) < uint256(-amount0))
                        {
                            IERC20Minimal(token0.erc223).transfer(address(converter), uint256(-amount0) - IERC20Minimal(token0.erc223).balanceOf(address(this)));
                        }
                        // Now there should be enough tokens to cover the payment.
                        TransferHelper.safeTransfer(token0.erc223, recipient, uint256(-amount0));
                    }
                }
                else
                {
                    // Optimistically attempt to transfer the full amount of tokens to the recipient.
                    (bool success, bytes memory data) =
                        token0.erc20.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, recipient, uint256(-amount0)));

                        //require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
                    if(!success)
                    {
                        // Not enough ERC-20 tokens on the pools balance
                        // Need to convert ERC-223 version to ERC-20 then deliver it to the user.

                        if(IERC20Minimal(token0.erc20).balanceOf(address(this)) < uint256(-amount0))
                        {
                            // Approve the converter first if necessary.
                            // This approval is expected to execute once and forever.
                            if(IERC20Minimal(token0.erc20).allowance(address(this), address(converter)) < uint256(-amount0))
                            {
                                IERC20Minimal(token0.erc20).approve(address(converter), 2**256-1);
                            }
                            converter.convertERC20(token0.erc20, uint256(-amount0) - IERC20Minimal(token0.erc20).balanceOf(address(this)));
                        }
                        // Now there should be enough tokens to cover the payment.
                        TransferHelper.safeTransfer(token0.erc20, recipient, uint256(-amount0));
                    }
                }
        }

        emit Swap(swap_sender, recipient, amount0, amount1, state.sqrtPriceX96, state.liquidity, state.tick);
        slot0.unlocked = true;
    }

}