// File: Contracts/TTSwapV1Gator.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "./libraries/base/LGate.sol";
import "./interfaces/Marketor/IMarketorV1State.sol";
import "./TTSwapV1Marketor.sol";
import "./interfaces/ITTSwapV1Gator.sol";

contract TTSwapV1Gator is ITTSwapV1Gator {
    //门户信息
    //Gateaddress=>GateInfo
    mapping(address => LGate.Info) public gateList;
    //Gateaddress=>GateInfo
    mapping(address => LGate.DetailInfo) public gateDetailList;
    //记录门户编号
    //GateNo=>Gateaddess
    mapping(uint128 => address) public gateNumbers;
    //记录市场中门户新增门户的编号
    uint128 public maxGateNumbers;

    //记录管理员合约地址
    address public override marketorContractAddress;
    //记录市场创建者地址
    address public marketCreator;

    //构建时
    constructor(address _marketorContractAddress, address _marketCreator) {
        marketorContractAddress = _marketorContractAddress;
        marketCreator = _marketCreator;
        maxGateNumbers = 1;
    }

    /// @notice 只能是通过市场管理员认证的门户可以调用
    /// @dev 只能是通过市场管理员认证的门户才可以调用
    modifier onlyGator() {
        require(
            gateList[msg.sender].marketunlock == true,
            "the caller must be valid gater"
        );
        _;
    }

    /// @notice 只能是市场创建者可以调用
    /// @dev 只能是市场创建者可以调用
    modifier onlyMarketCreator() {
        require(
            marketCreator == msg.sender,
            "the caller must be valid market creator"
        );
        _;
    }

    /// @notice 只能是通过市场认证的市场管理员户可以调用
    /// @dev 只能是通过市场认证的市场管理员户可以调用
    modifier onlyMarketor() {
        require(
            IMarketorV1State(marketorContractAddress).isValidMarketor(
                msg.sender
            ),
            "the caller must be valid market manager"
        );
        _;
    }

    /// @notice 设置门户合约的管理员合约
    /// @dev 设置门户合约的管理员合约
    function setGaterEnv(
        address _marketorContractAddress,
        address _marketCreator
    ) external override onlyMarketCreator {
        marketorContractAddress = _marketorContractAddress;
        marketCreator = _marketCreator;
    }

    /////////////////////////门户管理-市场////////////////////////////
    ///////////////////////// Gate Manage///////////////////////////
    /// @notice 市场管理员冻结门户
    /// @dev 市场管理员冻结门户
    function lockGatebyMarketor(
        address _gatoraddress
    ) external override onlyMarketor {
        require(
            gateList[_gatoraddress].isUsed == true,
            "the gator isnot exist"
        );
        gateList[_gatoraddress].marketunlock = false;
        emit e_lockGatebyMarketor(_gatoraddress, msg.sender);
    }

    /// @notice 市场管理员解冻门户
    /// @dev 市场管理员解冻门户
    function unlockGatebyMarketor(
        address _gatoraddress
    ) external override onlyMarketor {
        require(
            gateList[_gatoraddress].isUsed == true,
            "the gator isnot exist"
        );
        gateList[_gatoraddress].marketunlock = true;
        emit e_unlockGatebyMarketor(_gatoraddress, msg.sender);
    }

    /// @notice 市场管理员更新门户
    /// @dev 市场管理员更新门户
    function updateGatebyMarketor(
        LGate.Info memory _gator
    ) external override onlyMarketor {
        require(
            gateList[_gator.gateAddress].isUsed == true,
            "the gator is exister"
        );
        _gator.marketunlock = gateList[_gator.gateAddress].marketunlock;
        _gator.gateunlock = gateList[_gator.gateAddress].gateunlock;
        gateList[_gator.gateAddress] = _gator;
        emit e_updateGatebyMarketor(
            _gator.gateAddress,
            _gator.name,
            msg.sender
        );
    }

    /// @notice 市场管理员删除门户
    /// @dev 市场管理员删除门户
    function delGatebyMarketor(address _gator) external override onlyMarketor {
        require(gateList[_gator].isUsed == true, "the gator is exister");

        delete gateList[_gator];
        emit e_delGatebyMarketor(_gator, msg.sender);
    }

    ///////////////////////// 门户管理-门户////////////////////////////
    ///////////////////////// Gate Manage///////////////////////////
    /// @notice 市场认证后的门户临时冻结自己
    /// @dev 市场认证后的门户临时冻结自己
    function lockGatebyGater() external override onlyGator {
        require(
            gateList[msg.sender].isUsed == true &&
                gateList[msg.sender].gateAddress == msg.sender,
            "the gator isnot exist"
        );
        gateList[msg.sender].gateunlock = false;

        emit e_lockGatebyGater(msg.sender);
    }

    /// @notice 市场认证后的门户临时解冻自己
    /// @dev 市场认证后的门户临时解冻自己
    function unlockGatebyGater() external override onlyGator {
        require(
            gateList[msg.sender].isUsed == true &&
                gateList[msg.sender].gateAddress == msg.sender,
            "the gator isnot exist"
        );
        gateList[msg.sender].gateunlock = true;
        emit e_unlockGatebyGater(msg.sender);
    }

    /// @notice 市场认证后的门户临时更新自己
    /// @dev 市场认证后的门户临时更新自己
    function updateGatebyGator(bytes32 _name) external override onlyGator {
        gateList[msg.sender].name = _name;
        emit e_updateGatebyGator(msg.sender, _name);
    }

    /// @notice 申请成为门户
    /// @dev 申请成为门户
    function addGater(LGate.Info memory _gator) external override {
        require(
            gateList[_gator.gateAddress].isUsed != true,
            "the gator is exister"
        );
        require(_gator.gateAddress == msg.sender, "the gator is your");
        _gator.marketunlock = false; //默认是被冻结状态
        _gator.gateunlock = false; //默认是被冻结状态
        _gator.gateNo = maxGateNumbers; //门户编号
        _gator.createtimestamp = block.timestamp; //创建时间
        _gator.isUsed = true;
        require(maxGateNumbers + 1 > maxGateNumbers, "the gator is your");
        gateList[_gator.gateAddress] = _gator; //添加门户信息到门户列表
        gateNumbers[maxGateNumbers] = _gator.gateAddress;
        maxGateNumbers += 1;
        emit e_addGater(_gator.gateAddress, _gator.name);
    }

    /// @notice 门户添加门户详情信息
    /// @dev 门户添加门户详情信息
    function addGaterDetailInfo(
        LGate.DetailInfo memory _gatorDatailinfo
    ) external override {
        require(gateList[msg.sender].isUsed == true, "the gator is not exist");
        gateDetailList[msg.sender] = _gatorDatailinfo;
        emit e_addGaterDetail(msg.sender);
    }

    /// @notice 一次性添加门户信息
    /// @dev 一次性添加门户信息
    function addfullGater(
        LGate.Info memory _gator,
        LGate.DetailInfo memory _gatorDatailinfo
    ) external override {
        require(
            gateList[_gator.gateAddress].isUsed != true,
            "the gator is exister"
        );
        require(_gator.gateAddress == msg.sender, "the gator is your");

        _gator.marketunlock = false; //默认是被冻结状态
        _gator.gateunlock = false; //默认是被冻结状态
        _gator.gateNo = maxGateNumbers; //门户编号
        _gator.createtimestamp = block.timestamp; //创建时间
        _gator.isUsed = true; //创建时间
        require(maxGateNumbers + 1 > maxGateNumbers, "the gator is your");
        gateList[_gator.gateAddress] = _gator; //添加门户信息到门户列表
        gateNumbers[maxGateNumbers] = _gator.gateAddress;
        maxGateNumbers += 1;
        emit e_addGater(_gator.gateAddress, _gator.name);

        require(gateList[msg.sender].isUsed == true, "the gator is not exist");
        gateDetailList[msg.sender] = _gatorDatailinfo;
        emit e_addGaterDetail(msg.sender);
    }

    /// @notice 一次性更新门户信息
    /// @dev 一次性更新门户信息
    function updatefullGater(
        LGate.Info memory _gator,
        LGate.DetailInfo memory _gatorDatailinfo
    ) external override {
        require(
            gateList[_gator.gateAddress].isUsed == true,
            "the gator is not exist"
        );
        require(_gator.gateAddress == msg.sender, "the gator is your");
        gateList[msg.sender].name = _gator.name; //添加门户信息到门户列表
        emit e_updateGater(_gator.gateAddress, _gator.name);
        gateDetailList[msg.sender] = _gatorDatailinfo;
        emit e_updateGaterDetail(msg.sender);
    }

    /// @notice 判断调用者是否是市场已经认证门户
    /// @dev 判断调用者是否是市场已经认证门户
    function isValidGator() external view override returns (bool) {
        return gateList[msg.sender].marketunlock;
    }

    /// @notice 判断调用者是否是市场已经认证门户
    /// @dev 判断调用者是否是市场已经认证门户
    function isValidGator(
        address caller
    ) external view override returns (bool) {
        return gateList[caller].marketunlock;
    }

    /// @notice 调用者判断传入地址是否是市场已经认证门户
    /// @dev 调用者判断传入地址是否是市场已经认证门户
    function isValidGatorFromAddress(
        address vgaddress
    ) external view override returns (bool) {
        return gateList[vgaddress].marketunlock;
    }

    /// @notice 调用者判断传入地址是否是市场已经认证门户
    /// @dev 调用者判断传入地址是否是市场已经认证门户
    function isValidGatorWebFromAddress(
        address vgaddress,
        bytes32 webaddress
    ) external view override returns (bool) {
        require(
            webaddress == gateDetailList[vgaddress].OfficalIp,
            "address does not match the website"
        );
        return gateList[vgaddress].marketunlock;
    }

    /// @notice 获取门户调用者的门户编号
    /// @dev 获取门户调用者的门户编号
    function getGaterNo() external view override returns (uint128) {
        return gateList[msg.sender].gateNo;
    }

    /// @notice 调用者获取传入地址对应的门户编号
    /// @dev 调用者获取传入地址对应的门户编号
    function getGaterNoFromAddress(
        address _gateAddress
    ) external view override returns (uint128) {
        return gateList[_gateAddress].gateNo;
    }

    /// @notice 调用者获取门户编号对应的门户信息
    /// @dev 调用者获取门户编号对应的门户信息
    function getGaterInfo(
        uint8 _gateNumber
    ) external view override returns (LGate.Info memory) {
        return gateList[gateNumbers[_gateNumber]];
    }

    /// @notice 调用者获取门户地址对应的门户信息
    /// @dev 调用者获取门户地址对应的门户信息
    function getGaterInfo(
        address _gateaddress
    ) external view override returns (LGate.Info memory) {
        return gateList[_gateaddress];
    }

    /// @notice 通过门户地址获取门户详情
    /// @dev 通过门户地址获取门户详情
    function getGaterDetailInfo(
        address _gateaddress
    ) external view override returns (LGate.DetailInfo memory) {
        return gateDetailList[_gateaddress];
    }

    /// @notice 通过门户编号获取门户详情
    /// @dev 通过门户编号获取门户详情
    function getGaterDetailInfo(
        uint8 _gateNumber
    ) external view override returns (LGate.DetailInfo memory) {
        return gateDetailList[gateNumbers[_gateNumber]];
    }

    /// @notice 调用者获取市场最大门户编号、或者是下一个门户申请者的编号
    /// @dev 调用者获取市场最大门户编号、或者是下一个门户申请者的编号
    function getMaxGateNumber() external view override returns (uint128) {
        return maxGateNumbers;
    }
}

// File: Contracts/interfaces/ITTSwapV1Gator.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "./Gator/IGatorV1CustomerActions.sol";
import "./Gator/IGatorV1Events.sol";
import "./Gator/IGatorV1GatorActions.sol";
import "./Gator/IGatorV1Immutables.sol";
import "./Gator/IGatorV1MarketorActions.sol";
import "./Gator/IGatorV1State.sol";

/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface ITTSwapV1Gator is
    IGatorV1CustomerActions,
    IGatorV1Events,
    IGatorV1GatorActions,
    IGatorV1Immutables,
    IGatorV1MarketorActions,
    IGatorV1State
{

}

// File: Contracts/TTSwapV1Marketor.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "./interfaces/ITTSwapV1Marketor.sol";

contract TTSwapV1Marketor is ITTSwapV1Marketor {
    //市场管理员
    mapping(uint128 => address) public Marketors;
    //记录管理号编号
    //Marketoraddress=>MarketorNo
    mapping(address => uint128) public MarketorsNo;
    //记录市场管理员人数(包含已加人员)
    uint128 public maxMarketorNo;
    //记录市场创建者
    address public marketCreator;

    //初始化时
    constructor(address _marketCreator) {
        marketCreator = _marketCreator;
        maxMarketorNo = 1;
    }

    //只能市场创建者运行
    modifier onlyMarketCreator() {
        require(msg.sender == marketCreator);
        _;
    }

    //增加市场管理员
    function setMarketorByMarketCreator(
        address _owner
    ) external override onlyMarketCreator {
        require(
            maxMarketorNo + 1 >= maxMarketorNo,
            "maxMarketorNo connot increase"
        );
        maxMarketorNo += 1;
        MarketorsNo[_owner] = maxMarketorNo;
        Marketors[maxMarketorNo] = _owner;
        emit e_setMarketorByMarketCreator(_owner);
    }

    //删除市场管理员
    function delMarketorByMarketCreator(
        address _owner
    ) external override onlyMarketCreator {
        delete Marketors[MarketorsNo[_owner]];
        delete MarketorsNo[_owner];
        emit e_delMarketorByMarketCreator(_owner);
    }

    //判定执行者是否是管理员
    function isValidMarketor() external view override returns (bool) {
        return MarketorsNo[msg.sender] > 0 ? true : false;
    }

    //判定特定地址是否是管理员
    function isValidMarketor(
        address mkaddress
    ) external view override returns (bool) {
        return MarketorsNo[mkaddress] > 0 ? true : false;
    }

    //获取调用者的管理员编号
    function getMarketorNo() external view returns (uint128) {
        return MarketorsNo[msg.sender];
    }

    //获取特定地址的管理员编号
    function getMarketorNo(
        address _marketorAddress
    ) external view returns (uint128) {
        return MarketorsNo[_marketorAddress];
    }

    //获取当前最大编号
    function getMaxMarketorNo() external view returns (uint128) {
        return maxMarketorNo;
    }
}

// File: Contracts/interfaces/Marketor/IMarketorV1State.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IMarketorV1State {
    function isValidMarketor() external view returns (bool);

    function isValidMarketor(address) external view returns (bool);
}

// File: Contracts/libraries/base/LGate.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

library LGate {
    struct Info {
        // the address of the Market
        // 记录market地址
        //Gate编号
        uint128 gateNo;
        // 门户地址
        address gateAddress;
        // 门户简称
        bytes32 name;
        //创建时间
        uint256 createtimestamp;
        // 如果门户违反行为准则,进行冻结限制
        bool marketunlock; //true 表示已解冻 false表示已冻结
        // config by the gater
        bool gateunlock; //true 表示已解冻 false表示已冻结
        bool isUsed;
    }

    //相应接口
    struct DetailInfo {
        bytes32 full_name; //全称
        bytes32 country; //国家
        bytes32 OfficalWebsite; //官网
        bytes32 OfficalIp; //Ip
        bytes32 twriterUrl; //推特
        bytes32 bbsUrl; //bbs论坛地址
    }
}

// File: Contracts/interfaces/Gator/IGatorV1State.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "../../libraries/base/LGate.sol";

/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IGatorV1State {
    /// @notice 判断调用者是否是市场已经认证门户
    /// @dev 判断调用者是否是市场已经认证门户
    function isValidGator() external view returns (bool);

    function isValidGator(address caller) external view returns (bool);

    /// @notice 调用者判断传入地址是否是市场已经认证门户
    /// @dev 调用者判断传入地址是否是市场已经认证门户
    function isValidGatorFromAddress(
        address vgaddress
    ) external view returns (bool);

    /// @notice 调用者判断传入地址是否是市场已经认证门户
    /// @dev 调用者判断传入地址是否是市场已经认证门户
    function isValidGatorWebFromAddress(
        address vgaddress,
        bytes32 webaddress
    ) external view returns (bool);

    /// @notice 获取门户调用者的门户编号
    /// @dev 获取门户调用者的门户编号
    function getGaterNo() external view returns (uint128);

    /// @notice 调用者获取传入地址对应的门户编号
    /// @dev 调用者获取传入地址对应的门户编号
    function getGaterNoFromAddress(
        address _gateAddress
    ) external view returns (uint128);

    /// @notice 调用者获取门户编号对应的门户信息
    /// @dev 调用者获取门户编号对应的门户信息
    function getGaterInfo(
        uint8 _gateNumber
    ) external view returns (LGate.Info memory);

    /// @notice 调用者获取门户地址对应的门户信息
    /// @dev 调用者获取门户地址对应的门户信息
    function getGaterInfo(
        address _gateaddress
    ) external view returns (LGate.Info memory);

    /// @notice 通过门户地址获取门户详情
    /// @dev 通过门户地址获取门户详情
    function getGaterDetailInfo(
        address _gateaddress
    ) external view returns (LGate.DetailInfo memory);

    /// @notice 通过门户编号获取门户详情
    /// @dev 通过门户编号获取门户详情
    function getGaterDetailInfo(
        uint8 _gateNumber
    ) external view returns (LGate.DetailInfo memory);

    /// @notice 调用者获取市场最大门户编号、或者是下一个门户申请者的编号
    /// @dev 调用者获取市场最大门户编号、或者是下一个门户申请者的编号
    function getMaxGateNumber() external view returns (uint128);

    function marketorContractAddress() external view returns (address);
}

// File: Contracts/interfaces/Gator/IGatorV1MarketorActions.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
import "../../libraries/base/LGate.sol";

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IGatorV1MarketorActions {
    /// @notice 市场管理员冻结门户
    /// @dev 市场管理员冻结门户
    function lockGatebyMarketor(address _gatoraddress) external;

    /// @notice 市场管理员解冻门户
    /// @dev 市场管理员解冻门户
    function unlockGatebyMarketor(address _gatoraddress) external;

    /// @notice 市场管理员更新门户
    /// @dev 市场管理员更新门户
    function updateGatebyMarketor(LGate.Info memory _gator) external;

    /// @notice 市场管理员删除门户
    /// @dev 市场管理员删除门户
    function delGatebyMarketor(address _gator) external;

    /// @notice 设置门户合约的管理员合约
    /// @dev 设置门户合约的管理员合约
    function setGaterEnv(
        address _marketorContractAddress,
        address _marketCreator
    ) external;
}

// File: Contracts/interfaces/Gator/IGatorV1Immutables.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IGatorV1Immutables {

}

// File: Contracts/interfaces/Gator/IGatorV1GatorActions.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
import "../../libraries/base/LGate.sol";

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IGatorV1GatorActions {
    /// @notice 市场认证后的门户临时冻结自己
    /// @dev 市场认证后的门户临时冻结自己
    function lockGatebyGater() external;

    /// @notice 市场认证后的门户临时解冻自己
    /// @dev 市场认证后的门户临时解冻自己
    function unlockGatebyGater() external;

    /// @notice 市场认证后的门户临时更新自己
    /// @dev 市场认证后的门户临时更新自己
    function updateGatebyGator(bytes32 _name) external;

    function updatefullGater(
        LGate.Info memory _gator,
        LGate.DetailInfo memory _gatorDatailinfo
    ) external;
}

// File: Contracts/interfaces/Gator/IGatorV1Events.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IGatorV1Events {
    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param name The owner of the position and recipient of any minted liquidity
    event e_addGater(address gateAddress, bytes32 name);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param name The owner of the position and recipient of any minted liquidity
    event e_updateGatebyGator(address gateAddress, bytes32 name);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity

    event e_unlockGatebyGater(address gateAddress);
    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity

    event e_lockGatebyGater(address gateAddress);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param marketoraddress The owner of the position and recipient of any minted liquidity
    event e_delGatebyMarketor(address gateAddress, address marketoraddress);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param name The owner of the position and recipient of any minted liquidity
    /// @param marketoraddress The owner of the position and recipient of any minted liquidity
    event e_updateGatebyMarketor(
        address gateAddress,
        bytes32 name,
        address marketoraddress
    );

    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param marketoraddress The address that minted the liquidity

    event e_unlockGatebyMarketor(address gateAddress, address marketoraddress);
    /// @notice Emitted when liquidity is minted for a given position
    /// @param gateAddress The address that minted the liquidity
    /// @param marketoraddress The address that minted the liquidity

    event e_lockGatebyMarketor(address gateAddress, address marketoraddress);

    event e_addGaterDetail(address gateaddress);

    event e_updateGater(address, bytes32);

    event e_updateGaterDetail(address);
}

// File: Contracts/interfaces/Gator/IGatorV1CustomerActions.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
import "../../libraries/base/LGate.sol";

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IGatorV1CustomerActions {
    /// @notice 申请成为门户
    /// @dev 申请成为门户
    function addGater(LGate.Info memory _gator) external;

    /// @notice 门户添加门户详情信息(需要是申请成为的门户的地址才能调用)
    /// @dev 门户添加门户详情信息(需要是申请成为的门户的地址才能调用)
    function addGaterDetailInfo(LGate.DetailInfo memory) external;

    function addfullGater(
        LGate.Info memory _gator,
        LGate.DetailInfo memory _gatorDatailinfo
    ) external;
}

// File: Contracts/interfaces/ITTSwapV1Marketor.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "./Marketor/IMarketorV1Events.sol";
import "./Marketor/IMarketorV1Immutables.sol";
import "./Marketor/IMarketorV1MarketCreatorActions.sol";
import "./Marketor/IMarketorV1State.sol";

/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface ITTSwapV1Marketor is
    IMarketorV1Events,
    IMarketorV1Immutables,
    IMarketorV1MarketCreatorActions,
    IMarketorV1State
{

}

// File: Contracts/interfaces/Marketor/IMarketorV1MarketCreatorActions.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IMarketorV1MarketCreatorActions {
    function setMarketorByMarketCreator(address _owner) external;

    /// @notice Explain to an end user what this does
    /// @dev Explain to a developer any extra details
    function delMarketorByMarketCreator(address _owner) external;
}

// File: Contracts/interfaces/Marketor/IMarketorV1Immutables.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IMarketorV1Immutables {

}

// File: Contracts/interfaces/Marketor/IMarketorV1Events.sol



// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IMarketorV1Events {
    event e_setMarketorByMarketCreator(address);
    event e_delMarketorByMarketCreator(address);
}