Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

import {IOutrunAMMPair, OutrunAMMPair} from "./OutrunAMMPair.sol";
import {IOutrunAMMFactory} from "./interfaces/IOutrunAMMFactory.sol";

contract OutrunAMMFactory is IOutrunAMMFactory, Ownable {
    uint256 public immutable swapFeeRate;
    address public immutable pairImplementation;

    address public feeTo;
    address[] public allPairs;
    
    mapping(address => mapping(address => address)) public getPair;

    constructor(
        address owner_, 
        address pairImplementation_, 
        uint256 swapFeeRate_
    ) Ownable(owner_) {
        swapFeeRate = swapFeeRate_;
        pairImplementation = pairImplementation_;
    }

    function allPairsLength() external view returns (uint256) {
        return allPairs.length;
    }

    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, IdenticalAddresses());

        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), ZeroAddress());
        require(getPair[token0][token1] == address(0), PairExists()); // single check is sufficient

        bytes32 salt = keccak256(abi.encodePacked(token0, token1, swapFeeRate));
        pair = Clones.cloneDeterministic(pairImplementation, salt);
        IOutrunAMMPair(pair).initialize(token0, token1, swapFeeRate);
        
        getPair[token0][token1] = pair;
        getPair[token1][token0] = pair; // populate mapping in the reverse direction
        allPairs.push(pair);

        emit PairCreated(token0, token1, pair, allPairs.length);
    }

    function setFeeTo(address _feeTo) external onlyOwner {
        feeTo = _feeTo;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Clones.sol)

pragma solidity ^0.8.20;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 */
library Clones {
    /**
     * @dev A clone instance deployment failed.
     */
    error ERC1167FailedCreateClone();

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        if (instance == address(0)) {
            revert ERC1167FailedCreateClone();
        }
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        if (instance == address(0)) {
            revert ERC1167FailedCreateClone();
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {UQ112x112} from "../libraries/UQ112x112.sol";
import {FixedPoint128} from "../libraries/FixedPoint128.sol";
import {Initializable} from "../libraries/Initializable.sol";
import {IOutrunAMMPair} from "./interfaces/IOutrunAMMPair.sol";
import {ReentrancyGuard} from "../libraries/ReentrancyGuard.sol";
import {IOutrunAMMCallee} from "./interfaces/IOutrunAMMCallee.sol";
import {IOutrunAMMFactory} from "./interfaces/IOutrunAMMFactory.sol";
import {IOutrunAMMERC20, OutrunAMMERC20} from "./OutrunAMMERC20.sol";

contract OutrunAMMPair is IOutrunAMMPair, OutrunAMMERC20, ReentrancyGuard, Initializable {
    using UQ112x112 for uint224;

    bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
    uint256 public constant RATIO = 10000;
    uint256 public constant MINIMUM_LIQUIDITY = 1000;

    address public factory;
    address public token0;
    address public token1;
    uint256 public swapFeeRate;

    uint112 private reserve0; // uses single storage slot, accessible via getReserves
    uint112 private reserve1; // uses single storage slot, accessible via getReserves
    uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves

    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event

    uint256 public feeGrowthX128; // accumulate maker fee per LP X128
    mapping(address account => uint256) public feeGrowthRecordX128; // record the feeGrowthX128 when calc maker's append fee
    mapping(address account => uint256) public unClaimedFeesX128;

    function getPairTokens() external view override returns (address _token0, address _token1) {
        _token0 = token0;
        _token1 = token1;
    }

    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
        _reserve0 = reserve0;
        _reserve1 = reserve1;
        _blockTimestampLast = blockTimestampLast;
    }

    /**
     * @dev Preview unclaimed maker fee
     */
    function previewMakerFee() external view override returns (uint256 amount0, uint256 amount1) {
        address msgSender = msg.sender;
        uint256 feeAppendX128 = balanceOf[msgSender] * (feeGrowthX128 - feeGrowthRecordX128[msgSender]);
        uint256 unClaimedFeeX128 = unClaimedFeesX128[msgSender];
        
        if (feeAppendX128 > 0) unClaimedFeeX128 += feeAppendX128;
        if (unClaimedFeeX128 == 0) return (0, 0);

        uint256 rootKLast = Math.sqrt(kLast);
        amount0 = Math.mulDiv(unClaimedFeeX128, IERC20(token0).balanceOf(address(this)), FixedPoint128.Q128 * rootKLast);
        amount1 = Math.mulDiv(unClaimedFeeX128, IERC20(token1).balanceOf(address(this)), FixedPoint128.Q128 * rootKLast);
    }

    // called once by the factory at time of deployment
    function initialize(
        address _token0, 
        address _token1, 
        uint256 _swapFeeRate
    ) external initializer {
        require(_swapFeeRate < RATIO, FeeRateOverflow());

        token0 = _token0;
        token1 = _token1;
        swapFeeRate = _swapFeeRate;
        factory = msg.sender;
    }

    /**
     * @dev Mint liquidity (LP)
     * @param to - address to receive LP token and calc this address's maker fee
     * @notice this low-level function should be called from a contract which performs important safety checks
     */
    function mint(address to) external nonReentrant returns (uint256 liquidity) {
        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 balance1 = IERC20(token1).balanceOf(address(this));
        uint256 amount0 = balance0 - _reserve0;
        uint256 amount1 = balance1 - _reserve1;

        if (to != address(0)) _calcFeeX128(to);
        if (totalSupply == 0) {
            liquidity = Math.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
            _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
        } else {
            uint256 rootKLast = Math.sqrt(kLast);
            liquidity = Math.min(amount0 * rootKLast / _reserve0, amount1 * rootKLast / _reserve1);
        }

        require(liquidity > 0, InsufficientLiquidityMinted());

        _mint(to, liquidity);
        _update(balance0, balance1, _reserve0, _reserve1);

        kLast = uint256(reserve0) * uint256(reserve1); // reserve0 and reserve1 are up-to-date

        emit Mint(msg.sender, to, amount0, amount1);
    }

    /**
     * @dev Burn liquidity (LP) and withdraw token0 and token1
     * @param to - Address to receive token and calc this address's maker fee
     * @notice - this low-level function should be called from a contract which performs important safety checks
     */
    function burn(address to) external nonReentrant returns (uint256 amount0, uint256 amount1) {
        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        address _token0 = token0;
        address _token1 = token1;
        uint256 balance0 = IERC20(_token0).balanceOf(address(this));
        uint256 balance1 = IERC20(_token1).balanceOf(address(this));
        uint256 liquidity = balanceOf[address(this)];

        uint256 rootKLast = Math.sqrt(kLast);
        amount0 = liquidity * balance0 / rootKLast; // using balances ensures pro-rata distribution
        amount1 = liquidity * balance1 / rootKLast; // using balances ensures pro-rata distribution

        require(amount0 > 0 && amount1 > 0, InsufficientLiquidityBurned());

        _burn(address(this), liquidity);
        _safeTransfer(_token0, to, amount0);
        _safeTransfer(_token1, to, amount1);
        balance0 = IERC20(_token0).balanceOf(address(this));
        balance1 = IERC20(_token1).balanceOf(address(this));

        _update(balance0, balance1, _reserve0, _reserve1);

        kLast = uint256(reserve0) * uint256(reserve1); // reserve0 and reserve1 are up-to-date

        emit Burn(msg.sender, amount0, amount1, to);
    }

    /**
     * @dev Swap token
     * @param amount0Out - Amount of token0 output
     * @param amount1Out - Amount of token0 output
     * @param to - Address to output
     * @param referrer - Address of rebate referrer
     * @notice - this low-level function should be called from a contract which performs important safety checks
     */
    function swap(uint256 amount0Out, uint256 amount1Out, address to, address referrer, bytes calldata data) external nonReentrant {
        require(amount0Out > 0 || amount1Out > 0, InsufficientOutputAmount());
        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        require(amount0Out < _reserve0 && amount1Out < _reserve1, InsufficientLiquidity());

        uint256 balance0;
        uint256 balance1;
        address _token0 = token0;
        address _token1 = token1;
        {
            require(to != _token0 && to != _token1, InvalidTo());

            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
            if (data.length > 0) IOutrunAMMCallee(to).OutrunAMMCall(msg.sender, amount0Out, amount1Out, data);
            balance0 = IERC20(_token0).balanceOf(address(this));
            balance1 = IERC20(_token1).balanceOf(address(this));
        }

        uint256 amount0In;
        uint256 amount1In;
        unchecked {
            amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
            amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
        }
        require(amount0In > 0 || amount1In > 0, InsufficientInputAmount());
    
        uint256 rebateFee0;
        uint256 rebateFee1;
        uint256 protocolFee0;
        uint256 protocolFee1;
        uint256 _swapFeeRate = swapFeeRate;
        {
            uint256 balance0Adjusted = balance0 * RATIO - amount0In * _swapFeeRate;
            uint256 balance1Adjusted = balance1 * RATIO - amount1In * _swapFeeRate;
            
            require(
                balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * uint256(_reserve1) * RATIO ** 2,
                ProductKLoss()
            );

            address feeTo = _feeTo();
            (balance0, rebateFee0, protocolFee0) = _transferRebateAndProtocolFee(amount0In, balance0, _token0, referrer, feeTo);
            (balance1, rebateFee1, protocolFee1) = _transferRebateAndProtocolFee(amount1In, balance1, _token1, referrer, feeTo);
        }

        _update(balance0, balance1, _reserve0, _reserve1);

        {
            uint256 k = uint256(reserve0) * uint256(reserve1);
            // The market-making revenue from LPs that are proactively burned will be distributed to others
            uint256 actualSupply = totalSupply - proactivelyBurnedAmount;
            actualSupply = actualSupply == 0 ? 1 : actualSupply;
            feeGrowthX128 += (Math.sqrt(k) - Math.sqrt(kLast)) * FixedPoint128.Q128 / actualSupply;
            kLast = k;
        }

        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
        emit ProtocolFee(referrer, rebateFee0, rebateFee1, protocolFee0, protocolFee1);
    }

    /**
     * @dev Claim all the maker fee of msgSender
     * @notice - Claim global protocol fee simultaneously
     */
    function claimMakerFee() external override returns (uint256 amount0, uint256 amount1) {
        address msgSender = msg.sender;
        _calcFeeX128(msgSender);

        uint256 feeX128 = unClaimedFeesX128[msgSender];
        if (feeX128 == 0) return (0, 0);
        unClaimedFeesX128[msgSender] = 0;

        address _token0 = token0;
        address _token1 = token1;
        uint256 balance0 = IERC20(_token0).balanceOf(address(this));
        uint256 balance1 = IERC20(_token1).balanceOf(address(this));
        uint256 rootKLast = Math.sqrt(kLast);

        Math.mulDiv(feeX128, balance0, FixedPoint128.Q128 * rootKLast);
        amount0 = Math.mulDiv(feeX128, balance0, FixedPoint128.Q128 * rootKLast);
        amount1 = Math.mulDiv(feeX128, balance1, FixedPoint128.Q128 * rootKLast);        
        require(amount0 > 0 && amount1 > 0, InsufficientMakerFeeClaimed());

        _safeTransfer(_token0, msgSender, amount0);
        _safeTransfer(_token1, msgSender, amount1);

        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        balance0 = IERC20(_token0).balanceOf(address(this));
        balance1 = IERC20(_token1).balanceOf(address(this));
        _update(balance0, balance1, _reserve0, _reserve1);

        kLast = uint256(reserve0) * uint256(reserve1);
    }

    /**
     * @dev Force balances to match reserves
     * @param to - Address to receive excess tokens
     */
    function skim(address to) external nonReentrant {
        address _token0 = token0; // gas savings
        address _token1 = token1; // gas savings
        _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)) - reserve0);
        _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)) - reserve1);
    }

    /**
     * @dev Force reserves to match balances
     */
    function sync() external nonReentrant {
        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
    }

    function _safeTransfer(address token, address to, uint256 value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), TransferFailed());
    }

    /**
     * @dev update reserves and, on the first call per block, price accumulators
     */
    function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) internal {
        require(balance0 <= type(uint112).max && balance1 <= type(uint112).max, Overflow());

        uint32 blockTimestamp;
        uint32 timeElapsed;
        unchecked {
            blockTimestamp = uint32(block.timestamp % 2 ** 32);
            timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
        }
        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
            // * never overflows, and + overflow is desired
            unchecked {
                price0CumulativeLast += uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
                price1CumulativeLast += uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
            }
        }
        reserve0 = uint112(balance0);
        reserve1 = uint112(balance1);
        blockTimestampLast = blockTimestamp;

        emit Sync(reserve0, reserve1);
    }

    /**
     * @dev Transfer rebate and protocol fee
     */
    function _transferRebateAndProtocolFee(
        uint256 amountIn,
        uint256 balance,
        address token,
        address referrer,
        address feeTo
    ) internal returns(uint256 balanceAfter, uint256 rebateFee, uint256 protocolFee) {
        if (amountIn == 0 || feeTo == address(0)) {
            return (balance, 0, 0);
        }

        uint256 _swapFeeRate = swapFeeRate;
        if (referrer == address(0)) {
            // swapFee * 25% as protocolFee
            rebateFee = 0;
            protocolFee = amountIn * _swapFeeRate / (RATIO * 4);
            balanceAfter = balance - protocolFee;
            _safeTransfer(token, feeTo, protocolFee);
        } else {
            // swapFee * 25% * 20% as rebateFee, swapFee * 25% * 80% as protocolFee
            rebateFee = amountIn * _swapFeeRate / (RATIO * 20);
            protocolFee = amountIn * _swapFeeRate / (RATIO * 5);
            balanceAfter = balance - rebateFee - protocolFee;
            _safeTransfer(token, referrer, rebateFee);
            _safeTransfer(token, feeTo, protocolFee);
        }
    }

    /**
     * @dev Calculate the maker fee
     */
    function _calcFeeX128(address to) internal {
        uint256 _feeGrowthX128 = feeGrowthX128;
        unchecked {
            uint256 feeAppendX128 = balanceOf[to] * (_feeGrowthX128 - feeGrowthRecordX128[to]);
            if (feeAppendX128 > 0) {
                unClaimedFeesX128[to] += feeAppendX128;
            }
        }
        feeGrowthRecordX128[to] = _feeGrowthX128;
    }

    function _feeTo() internal view returns (address) {
        return IOutrunAMMFactory(factory).feeTo();
    }

    function _beforeTokenTransfer(address from, address to, uint256) internal override {
        if (from != address(0)) _calcFeeX128(from);
        if (to != address(0)) _calcFeeX128(to);
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

interface IOutrunAMMFactory {
    function swapFeeRate() external view returns (uint256);

    function pairImplementation() external view returns (address);
    
    function feeTo() external view returns (address);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function getPair(address tokenA, address tokenB) external view returns (address pair);


    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;


    error ZeroAddress();

    error PairExists();

    error IdenticalAddresses();
    

    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// 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-3.0
pragma solidity ^0.8.28;

// a library for handling binary fixed point numbers

// range: [0, 2**112 - 1]
// resolution: 1 / 2**112

library UQ112x112 {
    uint224 constant Q112 = 2 ** 112;

    // encode a uint112 as a UQ112x112
    function encode(uint112 y) internal pure returns (uint224 z) {
        unchecked {
            z = uint224(y) * Q112; // never overflows
        }
    }

    // divide a UQ112x112 by a uint112, returning a UQ112x112
    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
        z = x / uint224(y);
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

library FixedPoint128 {
    uint256 internal constant Q128 = 0x100000000000000000000000000000000;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

abstract contract Initializable {
    bool public initialized;

    error InvalidInitialization();

    modifier initializer() {
        require(!initialized, InvalidInitialization());

        initialized = true;
        _;
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

interface IOutrunAMMPair {
    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function feeGrowthX128() external view returns (uint256);
    
    function getPairTokens() external view returns (address _token0, address _token1);

    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function previewMakerFee() external view returns (uint256 amount0, uint256 amount1);


    function initialize(address token0, address token1, uint256 swapFeeRate) external;

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swap(uint256 amount0Out, uint256 amount1Out, address to, address referrer, bytes calldata data) external;

    function skim(address to) external;

    function sync() external;

    function claimMakerFee() external returns (uint256 amount0, uint256 amount1);


    error Locked();

    error Overflow();

    error Forbidden();

    error InvalidTo();

    error ProductKLoss();

    error TransferFailed();

    error FeeRateOverflow();

    error InsufficientLiquidity();

    error InsufficientInputAmount();

    error InsufficientOutputAmount();

    error InsufficientUnclaimedFee();

    error InsufficientLiquidityMinted();

    error InsufficientLiquidityBurned();

    error InsufficientMakerFeeClaimed();


    event Mint(address indexed sender, address indexed to, uint256 amount0, uint256 amount1);

    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);

    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );

    event ProtocolFee(
        address indexed referrer,
        uint256 rebateFee0,
        uint256 rebateFee1,
        uint256 protocolFee0,
        uint256 protocolFee1
    );

    event Sync(uint112 reserve0, uint112 reserve1);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

/**
 * @dev Outrun's ReentrancyGuard implementation, support transient variable. Modified from @openzeppelin implementation
 */
abstract contract ReentrancyGuard {
    bool transient locked;

    error ReentrancyGuardReentrantCall();

    modifier nonReentrant() {
        require(!locked, ReentrancyGuardReentrantCall());
        locked = true;
        _;
        locked = false;
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

interface IOutrunAMMCallee {
    function OutrunAMMCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external;
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

import {IOutrunAMMERC20} from "./interfaces/IOutrunAMMERC20.sol";

/**
 * @dev OutrunAMM's ERC20 implementation, modified from @solmate implementation
 */
abstract contract OutrunAMMERC20 is IOutrunAMMERC20 {
    string public constant name = "Outrun AMM";

    string public constant symbol = "OUT-AMM";

    uint8 public constant decimals = 18;

    uint256 public totalSupply;

    uint256 public proactivelyBurnedAmount;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {}

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(msg.sender, to, amount);

        if (to == address(0)) proactivelyBurnedAmount += amount;

        balanceOf[msg.sender] -= amount;

        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _beforeTokenTransfer(from, to, amount);

        uint256 allowed = allowance[from][msg.sender];

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        if (to == address(0)) proactivelyBurnedAmount += amount;

        balanceOf[from] -= amount;

        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    function _mint(address to, uint256 amount) internal virtual {
        if (to == address(0)) proactivelyBurnedAmount += amount;
        
        totalSupply += amount;

        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.28;

interface IOutrunAMMERC20 {
    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);


    function approve(address spender, uint256 value) external returns (bool);
    
    function transfer(address to, uint value) external returns (bool);

    function transferFrom(address from, address to, uint value) external returns (bool);


    event Transfer(address indexed from, address indexed to, uint256 value);
    
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "solmate/=lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 100000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": true,
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"pairImplementation_","type":"address"},{"internalType":"uint256","name":"swapFeeRate_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ERC1167FailedCreateClone","type":"error"},{"inputs":[],"name":"IdenticalAddresses","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"PairExists","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token0","type":"address"},{"indexed":true,"internalType":"address","name":"token1","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"PairCreated","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allPairs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allPairsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"}],"name":"createPair","outputs":[{"internalType":"address","name":"pair","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeTo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeTo","type":"address"}],"name":"setFeeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapFeeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000cae21365145c467f8957607ae364fb29ee07320900000000000000000000000049178128717080305d6506eb24e71e0cea68bf8f000000000000000000000000000000000000000000000000000000000000001e

-----Decoded View---------------
Arg [0] : owner_ (address): 0xcae21365145C467F8957607aE364fb29Ee073209
Arg [1] : pairImplementation_ (address): 0x49178128717080305d6506eb24E71e0CEA68bF8f
Arg [2] : swapFeeRate_ (uint256): 30

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000cae21365145c467f8957607ae364fb29ee073209
Arg [1] : 00000000000000000000000049178128717080305d6506eb24e71e0cea68bf8f
Arg [2] : 000000000000000000000000000000000000000000000000000000000000001e