Contract Source Code:

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

interface IERC20 {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

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

    function decimals() external view 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, uint256 value) external returns (bool);

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

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

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

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

interface IOnlyMemesERC20 {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view 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, uint256 value) external returns (bool);

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

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

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

interface IOnlyMemesFactory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

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

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

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

import {IOnlyMemesERC20} from "./IOnlyMemesERC20.sol";
import "contracts/interfaces/IVoter.sol";

interface IOnlyMemesPair is IOnlyMemesERC20 {
    event Mint(address indexed sender, 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 Sync(uint112 reserve0, uint112 reserve1);

    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 getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    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,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;

    function setPID(uint256 pid) external;
    function setFeeAddresses(IVoter, address, address) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

interface IVoter {
    function isBribeWhitelisted(address token) external view returns (bool);
    function setWhitelistedBribe(address token, bool status) external;
    function bribe(uint256 pid, address reward, uint256 amount) external;
    function _lastEpoch() external view returns (uint256);
    function _epochLength() external view returns(uint256);
    function _unlockTokens(address owner) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

// a library for performing various math operations

library Math {
    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x < y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.4;

// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))

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

library UQ112x112 {
    //solhint-disable-next-line state-visibility
    uint224 constant Q112 = 2 ** 112;

    // encode a uint112 as a UQ112x112
    function encode(uint112 y) internal pure returns (uint224 z) {
        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-or-later

pragma solidity ^0.8.4;

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

contract OnlyMemesERC20 is IOnlyMemesERC20 {
    string public override name;
    string public override symbol;
    uint8 public constant override decimals = 18;
    uint256 public override totalSupply;
    mapping(address => uint256) public override balanceOf;
    mapping(address => mapping(address => uint256)) public override allowance;

    bytes32 public override DOMAIN_SEPARATOR;
    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant override PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
    mapping(address => uint256) public override nonces;

     constructor(string memory _name, string memory _symbol) {
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                ),
                keccak256(bytes(_name)),
                name = _name,
                symbol = _symbol,
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );
    }

    function _mint(address to, uint256 value) internal {
        totalSupply += value;
        balanceOf[to] += value;
        emit Transfer(address(0), to, value);
    }

    function _burn(address from, uint256 value) internal {
        balanceOf[from] -= value;
        totalSupply -= value;
        emit Transfer(from, address(0), value);
    }

    function _approve(address owner, address spender, uint256 value) private {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _transfer(address from, address to, uint256 value) private {
        balanceOf[from] -= value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
    }

    function approve(
        address spender,
        uint256 value
    ) external override returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(
        address to,
        uint256 value
    ) external override returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external override returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) {
            allowance[from][msg.sender] -= value;
        }
        _transfer(from, to, value);
        return true;
    }

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external override {
        require(deadline >= block.timestamp, "OnlyMemes: EXPIRED");
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                keccak256(
                    abi.encode(
                        PERMIT_TYPEHASH,
                        owner,
                        spender,
                        value,
                        nonces[owner]++,
                        deadline
                    )
                )
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(
            recoveredAddress != address(0) && recoveredAddress == owner,
            "OnlyMemes: INVALID_SIGNATURE"
        );
        _approve(owner, spender, value);
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;

import {IOnlyMemesFactory} from "./interfaces/IOnlyMemesFactory.sol";
import {IOnlyMemesPair} from "./interfaces/IOnlyMemesPair.sol";
import {OnlyMemesPair} from "./OnlyMemesPair.sol";
import {IVoter} from "./interfaces/IVoter.sol";

contract OnlyMemesFactory is IOnlyMemesFactory {

    address public override feeTo;
    address public override feeToSetter;
    address public immutable multisig;
    IVoter public immutable voter;
    address public immutable chef;

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

    constructor(
        address _feeToSetter,
        IVoter _voter,
        address _multisig,
        address _chef
    ) {
        require(_feeToSetter != address(0), "OnlyMemes: ZERO_ADDRESS");
        require(address(_voter) != address(0), "OnlyMemes: ZERO_VOTER");
        require(_multisig != address(0), "OnlyMemes: ZERO_MULTISIG");
        
        feeToSetter = _feeToSetter;
        voter = _voter;
        multisig = _multisig;
        chef = _chef;
    }

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

    function createPair(
        address tokenA,
        address tokenB
    ) external override returns (address pair) {
        require(tokenA != tokenB, "OnlyMemes: IDENTICAL_ADDRESSES");
        (address token0, address token1) = tokenA < tokenB
            ? (tokenA, tokenB)
            : (tokenB, tokenA);
        require(token0 != address(0), "OnlyMemes: ZERO_ADDRESS");
        require(
            getPair[token0][token1] == address(0),
            "OnlyMemes: PAIR_EXISTS"
        );

        string memory _symbol = string(abi.encodePacked(OnlyMemesPair(tokenA).symbol(), "/" ,  OnlyMemesPair(tokenB).symbol()));
       string memory name = string(abi.encodePacked("OnlyMemes LP ", _symbol));
        string memory symbol = string(abi.encodePacked("ONLY LP-", _symbol));
pair = address
(new OnlyMemesPair{
    salt: keccak256(abi.encodePacked(token0, token1))
            }(name, symbol)
        );
        
        IOnlyMemesPair(pair).initialize(token0, token1);
        IOnlyMemesPair(pair).setFeeAddresses(voter, multisig, chef);
        
        getPair[token0][token1] = pair;
        getPair[token1][token0] = pair; 
        allPairs.push(pair);
        
        emit PairCreated(token0, token1, pair, allPairs.length);
    }
    function setFeeTo(address _feeTo) external override {
        require(msg.sender == feeToSetter, "OnlyMemes: FORBIDDEN");
        feeTo = _feeTo;
    }

    function setFeeToSetter(address _feeToSetter) external override {
        require(msg.sender == feeToSetter, "OnlyMemes: FORBIDDEN");
        require(_feeToSetter != address(0), "OnlyMemes: ZERO_ADDRESS");
        feeToSetter = _feeToSetter;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;

import {IOnlyMemesPair} from "./interfaces/IOnlyMemesPair.sol";
import {OnlyMemesERC20} from "./OnlyMemesERC20.sol";
import {Math} from "./libraries/Math.sol";
import {UQ112x112} from "./libraries/UQ112x112.sol";
import {IERC20} from "./interfaces/IERC20.sol";
import "contracts/interfaces/IOnlyMemesCallee.sol";
import "contracts/interfaces/IOnlyMemesFactory.sol";
import "contracts/interfaces/IVoter.sol";



contract OnlyMemesPair is IOnlyMemesPair, OnlyMemesERC20 {
    using UQ112x112 for uint224;

    uint256 public constant override MINIMUM_LIQUIDITY = 10**3;

    address public override factory;
    address public override token0;
    address public override token1;
    IVoter public voter;
    address public multisig;
    address public chef;
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private blockTimestampLast;
    uint256 private Pid;
    uint256 public override price0CumulativeLast;
    uint256 public override price1CumulativeLast;
    uint256 public override kLast;
    

    uint256 private unlocked = 1;
    
    error AddressNotSet();
    error CalculationOverflow();

    modifier lock() {
        require(unlocked == 1, "OnlyMemes: LOCKED");
        unlocked = 0;
        _;
        unlocked = 1;
    }

    constructor(string memory _name, string memory _symbol) OnlyMemesERC20(_name, _symbol) {
        factory = msg.sender;
        

    }

    function setFeeAddresses(IVoter _voter, address _multisig, address _chef) external {
        require(msg.sender == factory, "OnlyMemes: FORBIDDEN");
        require(address(_voter) != address(0) && _multisig != address(0), "OnlyMemes: ZERO_ADDRESS");
        voter = _voter;
        multisig = _multisig;
        chef = _chef;
    }

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

    function _safeTransfer(address token, address to, uint256 value) private {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.transfer.selector, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "OnlyMemes: TRANSFER_FAILED"
        );
    }

    function initialize(address _token0, address _token1) external override {
        require(msg.sender == factory, "OnlyMemes: FORBIDDEN");
        token0 = _token0; 
        token1 = _token1;
    }

    function _update(
        uint256 balance0,
        uint256 balance1,
        uint112 _reserve0,
        uint112 _reserve1
    ) private {
        require(
            balance0 <= type(uint112).max && balance1 <= type(uint112).max,
            "OnlyMemes: OVERFLOW"
        );
        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
        unchecked {
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                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);
    }

    function calculateTokenAmount(
        uint256 reserve,
        uint256 share,
        uint256 _totalSupply
    ) external pure returns (uint256) {
        return (share * reserve) / _totalSupply;
    }

   function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
        address feeTo = IOnlyMemesFactory(factory).feeTo();
        feeOn = feeTo != address(0);
        uint256 _kLast = kLast;
        
        if (feeOn) {
            if (_kLast != 0) {
                if (address(voter) == address(0) || multisig == address(0)) revert AddressNotSet();
                
                uint256 rootK = Math.sqrt(uint256(_reserve0) * _reserve1);
                uint256 rootKLast = Math.sqrt(_kLast);
                if (rootK > rootKLast) {
                    uint256 numerator = totalSupply * (rootK - rootKLast);
                    uint256 denominator = rootK + rootKLast;
                    uint256 totalLiquidity = numerator / denominator;
                    
                    if (totalLiquidity > 0) {
                        bool isWhitelisted = voter.isBribeWhitelisted(address(this));
                        uint256 voterShare = (totalLiquidity * 30) / 100;
                        uint256 multisigShare = (totalLiquidity * 5) / 100;
                        uint256 lpShare = isWhitelisted ? 
                            (totalLiquidity * 15) / 100 : 
                            (totalLiquidity * 45) / 100; // 15% base + 30% from voter share
                        
                        // Only bribe if whitelisted
                        if (isWhitelisted) {
                            try this.calculateTokenAmount(_reserve0, voterShare, totalSupply) returns (uint256 amount0Voter) {
                                try this.calculateTokenAmount(_reserve1, voterShare, totalSupply) returns (uint256 amount1Voter) {
                                    _safeApprove(token0, address(voter), amount0Voter);
                                    _safeApprove(token1, address(voter), amount1Voter);
                                    voter.bribe(Pid, token0, amount0Voter);
                                    voter.bribe(Pid, token1, amount1Voter);
                                } catch {
                                    revert CalculationOverflow();
                                }
                            } catch {
                                revert CalculationOverflow();
                            }
                        }
                        
                        // Calculate and transfer multisig share
                        try this.calculateTokenAmount(_reserve0, multisigShare, totalSupply) returns (uint256 amount0Multisig) {
                            try this.calculateTokenAmount(_reserve1, multisigShare, totalSupply) returns (uint256 amount1Multisig) {
                                _safeTransfer(token0, multisig, amount0Multisig);
                                _safeTransfer(token1, multisig, amount1Multisig);
                            } catch {
                                revert CalculationOverflow();
                            }
                        } catch {
                            revert CalculationOverflow();
                        }
                        
                        // Mint LP to multisig
                        if (lpShare > 0) _mint(multisig, lpShare);
                        
                        // Update reserves to match new balances after transfers
                        _update(
                            IERC20(token0).balanceOf(address(this)),
                            IERC20(token1).balanceOf(address(this)),
                            reserve0,
                            reserve1
                        );
                    }
                }
            }
        } else if (_kLast != 0) {
            kLast = 0;
        }
    }

    function mint(address to) external override lock returns (uint256 liquidity) {
        (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 balance1 = IERC20(token1).balanceOf(address(this));
        uint256 amount0 = balance0 - _reserve0;
        uint256 amount1 = balance1 - _reserve1;

        bool feeOn = _mintFee(_reserve0, _reserve1);
        uint256 _totalSupply = totalSupply;
        if (_totalSupply == 0) {
            liquidity = Math.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
            _mint(address(0), MINIMUM_LIQUIDITY);
        } else {
            liquidity = Math.min(
                (amount0 * _totalSupply) / _reserve0,
                (amount1 * _totalSupply) / _reserve1
            );
        }
        require(liquidity > 0, "OnlyMemes: INSUFFICIENT_LIQUIDITY_MINTED");
        _mint(to, liquidity);

        _update(balance0, balance1, _reserve0, _reserve1);
        if (feeOn) kLast = uint256(reserve0) * reserve1;
        emit Mint(msg.sender, amount0, amount1);
    }

    function burn(address to) external override lock 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)];

        bool feeOn = _mintFee(_reserve0, _reserve1);
        uint256 _totalSupply = totalSupply;
        amount0 = (liquidity * balance0) / _totalSupply;
        amount1 = (liquidity * balance1) / _totalSupply;
        require(
            amount0 > 0 && amount1 > 0,
            "OnlyMemes: INSUFFICIENT_LIQUIDITY_BURNED"
        );
        _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);
        if (feeOn) kLast = uint256(reserve0) * reserve1;
        emit Burn(msg.sender, amount0, amount1, to);
    }

    function swap(
    uint256 amount0Out,
    uint256 amount1Out,
    address to,
    bytes calldata data
) external override lock { 
    require(amount0Out > 0 || amount1Out > 0, "OnlyMemes: INSUFFICIENT_OUTPUT_AMOUNT");
    (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
    require(amount0Out < _reserve0 && amount1Out < _reserve1, "OnlyMemes: INSUFFICIENT_LIQUIDITY");

    uint256 balance0;
    uint256 balance1;
    { // scope for _token{0,1}, avoids stack too deep errors
        address _token0 = token0;
        address _token1 = token1;
        require(to != _token0 && to != _token1, "OnlyMemes: INVALID_TO");
        if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
        if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
        if (data.length > 0) IOnlyMemesCallee(to).OnlyMemesCall(msg.sender, amount0Out, amount1Out, data);
        balance0 = IERC20(_token0).balanceOf(address(this));
        balance1 = IERC20(_token1).balanceOf(address(this));
    }
    uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    require(amount0In > 0 ||  amount1In > 0, "OnlyMemes: INSUFFICIENT_INPUT_AMOUNT");
    { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
        require(
            amount0In * 99 * _reserve1 >= amount1Out * 100 * _reserve0 &&
            amount1In * 99 * _reserve0 >= amount0Out * 100 * _reserve1,
            "OnlyMemes: K"
        );
    }

        _update(balance0, balance1, _reserve0, _reserve1);
        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
    }

     function _safeApprove(address token, address spender, uint256 value) private {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.approve.selector, spender, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "OnlyMemes: APPROVE_FAILED"
        );
    }


    function skim(address to) external override lock {
        address _token0 = token0;
        address _token1 = token1;
        _safeTransfer(
            _token0,
            to,
            IERC20(_token0).balanceOf(address(this)) - reserve0
        );
        _safeTransfer(
            _token1,
            to,
            IERC20(_token1).balanceOf(address(this)) - reserve1
        );
    }

    function sync() external override lock {
        _update(
            IERC20(token0).balanceOf(address(this)),
            IERC20(token1).balanceOf(address(this)),
            reserve0,
            reserve1
        );
    }
    function setPID(uint256 pid) external {
        require (msg.sender == chef);
        Pid = pid;
    }
}