add Mint function

Author: yuriy77k

contracts/Ownable.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: No License (None)
+pragma solidity =0.5.16;
+
+/**
+ * @title Ownable
+ * @dev The Ownable contract has an owner address, and provides basic authorization control
+ * functions, this simplifies the implementation of "user permissions".
+ *
+ * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/ownership/Ownable.sol
+ * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts
+ * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the
+ * build/artifacts folder) as well as the vanilla Ownable implementation from an openzeppelin version.
+ */
+contract Ownable {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+     * account.
+     */
+    constructor () internal {
+        _owner = msg.sender;
+        emit OwnershipTransferred(address(0), _owner);
+    }
+
+    /**
+     * @return the address of the owner.
+     */
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(isOwner(),"Not Owner");
+        _;
+    }
+
+    /**
+     * @return true if `msg.sender` is the owner of the contract.
+     */
+    function isOwner() public view returns (bool) {
+        return msg.sender == _owner;
+    }
+
+    /**
+     * @dev Allows the current owner to relinquish control of the contract.
+     * @notice Renouncing to ownership will leave the contract without an owner.
+     * It will not be possible to call the functions with the `onlyOwner`
+     * modifier anymore.
+     */
+    function renounceOwnership() public onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+    /**
+     * @dev Allows the current owner to transfer control of the contract to a newOwner.
+     * @param newOwner The address to transfer ownership to.
+     */
+    function transferOwnership(address newOwner) public onlyOwner {
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers control of the contract to a newOwner.
+     * @param newOwner The address to transfer ownership to.
+     */
+    function _transferOwnership(address newOwner) internal {
+        require(newOwner != address(0),"Zero address not allowed");
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+}

contracts/UniswapV2Factory.sol

@@ -1,22 +1,24 @@
 pragma solidity =0.5.16;
 
-import './interfaces/IUniswapV2Factory.sol';
 import './UniswapV2Pair.sol';
+import "./Ownable.sol";
+
+contract UniswapV2Factory is Ownable {
 
-contract UniswapV2Factory is IUniswapV2Factory {
-    address public feeTo;
-    address public feeToSetter;
     address public constant BNB = 0x0000000000000000000000000000000000000001;
 
     mapping(address => mapping(address => address)) public getPair;
     address[] public allPairs;
 
+    mapping(address => bool) isAllowedAddress;
     event PairCreated(address indexed token0, address indexed token1, address pair, uint);
 
-    constructor(address _feeToSetter) public {
-        feeToSetter = _feeToSetter;
+    function changeAllowedAddress(address _which,bool _bool) external onlyOwner returns(bool){
+        isAllowedAddress[_which] = _bool;
+        return true;
     }
 
+
     function allPairsLength() external view returns (uint) {
         return allPairs.length;
     }
@@ -38,18 +40,22 @@ contract UniswapV2Factory is IUniswapV2Factory {
         emit PairCreated(token0, token1, pair, allPairs.length);
     }
 
-    function setFeeTo(address _feeTo) external {
-        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
-        feeTo = _feeTo;
-    }
+    function cratePool(address tokenA, address tokenB, uint amountA, uint amountB, address payable to) external payable returns(address pair, uint liquidity) {
+        pair = createPair(tokenA, tokenB);
+        bool isBNB;
+        if (tokenA == BNB) isBNB = true;
+        else safeTransferFrom(tokenA, msg.sender, pair, amountA);
 
-    function setFeeToSetter(address _feeToSetter) external {
-        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
-        feeToSetter = _feeToSetter;
+        if (tokenB == BNB) isBNB = true;
+        else safeTransferFrom(tokenB, msg.sender, pair, amountB);
+
+        if (isBNB) liquidity = IUniswapV2Pair(pair).mint.value(msg.value)(to);
+        else liquidity = IUniswapV2Pair(pair).mint(to);
     }
 
-    function cratePool(address tokenA, address tokenB, uint amountA, uint amountB, address payable to) external payable returns(address pair, uint liquidity) {
-        pair = createPair(tokenA, tokenB);
+    function mint(address tokenA, address tokenB, uint amountA, uint amountB, address payable to) external payable returns(uint liquidity) {
+        require(isAllowedAddress[msg.sender],"ERR_ALLOWED_ADDRESS_ONLY");
+        address pair = getPair[tokenA][tokenB];
         bool isBNB;
         if (tokenA == BNB) isBNB = true;
         else safeTransferFrom(tokenA, msg.sender, pair, amountA);