Contract Address Details

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

import './interfaces/IBlazeSwapFactory.sol';
import './BlazeSwapBaseFactory.sol';
import './BlazeSwapPair.sol';

contract BlazeSwapFactory is IBlazeSwapFactory, BlazeSwapBaseFactory {
    mapping(address => bool) public isFlareAssetPairWithoutPlugin;

    constructor(address _manager) BlazeSwapBaseFactory(_manager) {}

    function pairCreationCode() internal pure virtual override returns (bytes memory code) {
        code = type(BlazeSwapPair).creationCode;
    }

    function initializePair(address pair, address token0, address token1) internal virtual override {
        super.initializePair(pair, token0, token1);
        IBlazeSwapManager m = IBlazeSwapManager(manager);
        BlazeSwapPair p = BlazeSwapPair(payable(pair));
        TokenType type0 = m.getTokenType(token0);
        TokenType type1 = m.getTokenType(token1);
        p.initialize(manager, token0, token1, type0, type1);
        if (type0 != TokenType.Generic || type1 != TokenType.Generic) {
            // the following code assumes that the delegation and ftsoRewards
            // plugins are available from the beginning
            p.addPlugin(m.delegationPlugin());
            if (type0 == TokenType.WNat || type1 == TokenType.WNat) {
                p.addPlugin(m.ftsoRewardPlugin());
                if (block.chainid == 14 || block.chainid == 114) {
                    p.addPlugin(m.airdropPlugin());
                }
            }
            if (type0 == TokenType.FlareAsset || type1 == TokenType.FlareAsset) {
                FlareAssetSupport flareAssetSupport = m.flareAssetSupport();
                if (flareAssetSupport == FlareAssetSupport.Full) {
                    p.addPlugin(m.flareAssetRewardPlugin());
                } else if (flareAssetSupport == FlareAssetSupport.Minimal) {
                    isFlareAssetPairWithoutPlugin[pair] = true;
                } else {
                    revert('BlazeSwap: FASSET_UNSUPPORTED');
                }
            }
        }
    }

    function upgradeFlareAssetPair(address pair) external {
        IBlazeSwapManager m = IBlazeSwapManager(manager);
        address plugin = m.flareAssetRewardPlugin();
        require(plugin != address(0) && isFlareAssetPairWithoutPlugin[pair], 'BlazeSwap: UPGRADE_NOT_NEEDED');
        isFlareAssetPairWithoutPlugin[pair] = false;
        BlazeSwapPair(payable(pair)).addPlugin(plugin);
    }
}
        

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import './flare/IFtsoRewardManager.sol';
import './IBlazeSwapBaseManager.sol';
import './Enumerations.sol';

interface IBlazeSwapManager is IBlazeSwapBaseManager {
    event AddFtsoRewardManager(address ftsoRewardManager);

    function updateFtsoRewardManagers(uint256 upTo) external;

    function getFtsoRewardManagers() external view returns (IFtsoRewardManager[] memory);

    function getActiveFtsoRewardManagers() external view returns (IFtsoRewardManager[] memory);

    function setRewardsFeeTo(address _rewardsFeeTo) external;

    function rewardsFeeTo() external view returns (address);

    function setFtsoRewardsFeeBips(uint256 _bips) external;

    function ftsoRewardsFeeBips() external view returns (uint256);

    function setFlareAssetRewardsFeeBips(uint256 _bips) external;

    function flareAssetRewardsFeeBips() external view returns (uint256);

    function setAirdropFeeBips(uint256 _bips) external;

    function airdropFeeBips() external view returns (uint256);

    function wNat() external view returns (address);

    function executorManager() external view returns (address);

    function getTokenType(address token) external view returns (TokenType tokenType);

    function delegationPlugin() external view returns (address);

    function ftsoRewardPlugin() external view returns (address);

    function airdropPlugin() external view returns (address);

    function flareAssetRewardPlugin() external view returns (address);

    function setFlareAssetRegistry(address _flareAssetRegistry) external;

    function flareAssetRegistry() external view returns (address registry);

    function setAllowFlareAssetPairsWithoutPlugin(bool _allowFlareAssetPairsWithoutPlugin) external;

    function allowFlareAssetPairsWithoutPlugin() external view returns (bool);

    function setDelegationPlugin(address _delegationPlugin) external;

    function setFtsoRewardPlugin(address _ftsoRewardPlugin) external;

    function setAirdropPlugin(address _airdropPlugin) external;

    function setFlareAssetsRewardPlugin(address _flareAssetRewardPlugin) external;

    function flareAssetSupport() external view returns (FlareAssetSupport);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '../../shared/interfaces/IConfigurable.sol';

interface IBlazeSwapBaseManager is IConfigurable {
    function mathContext() external returns (address);

    function setTradingFeeTo(address _tradingFeeTo) external;

    function tradingFeeTo() external view returns (address);

    function setTradingFeeSplit(address router, address _recipient, uint256 _bips) external;

    function getTradingFeeSplit(address router) external view returns (address recipient, uint256 bips);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IERC20Metadata {
    function name() external view returns (string memory);

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

    function decimals() external view returns (uint8);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IERC20Snapshot {
    function totalSupplyAt(uint256 block) external view returns (uint256);

    function balanceOfAt(address owner, uint256 block) external view returns (uint256);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './interfaces/IBlazeSwapMulticall.sol';

import '../shared/libraries/DelegateCallHelper.sol';

abstract contract BlazeSwapMulticall is IBlazeSwapMulticall {
    function multicall(bytes[] calldata data) external returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i; i < data.length; i++) {
            results[i] = DelegateCallHelper.delegateAndCheckResult(address(this), data[i]);
        }
    }
}
          

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

interface IBlazeSwapPlugin {
    function implementation() external view returns (address);
}
          

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

import './IBlazeSwapPluginImpl.sol';

interface IIBlazeSwapPluginImpl is IBlazeSwapPluginImpl {
    function initialize(address plugin) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IBlazeSwapMulticall {
    function multicall(bytes[] calldata data) external returns (bytes[] memory results);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '../erc20/IERC20.sol';
import '../erc20/IERC20Metadata.sol';
import '../erc20/IERC20Snapshot.sol';
import './IVPToken.sol';

interface IWNat is IERC20, IERC20Metadata, IERC20Snapshot, IVPToken {
    event Deposit(address indexed dst, uint256 amount);
    event Withdrawal(address indexed src, uint256 amount);

    function deposit() external payable;

    function depositTo(address recipient) external payable;

    function withdraw(uint256) external;

    function withdrawFrom(address owner, uint256 amount) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

interface IDiamondCut {
    enum FacetCutAction {
        Add,
        Replace,
        Remove
    }
    // Add=0, Replace=1, Remove=2

    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }

    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
}
          

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

// helper methods for interacting with ERC20 tokens and sending NAT that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper::safeApprove');
    }

    function safeTransfer(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper::safeTransfer');
    }

    function safeTransferFrom(address token, address from, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper::transferFrom');
    }

    function safeTransferNAT(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferNAT');
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IPriceSubmitter {
    function getFtsoManager() external view returns (address);
}
          

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

import './IIBlazeSwapPluginImpl.sol';

interface IIBlazeSwapDelegation is IIBlazeSwapPluginImpl {
    function transferDelegatorVotes(address from, address to, uint256 amount) external;

    function withdrawRewardFees(bool wrapped) external returns (uint256 rewardFees);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import './erc20/IERC20.sol';
import './erc20/IERC20Metadata.sol';
import './erc20/IERC20Permit.sol';

interface IBlazeSwapBasePair is IERC20, IERC20Metadata, IERC20Permit {
    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 manager() 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 mintFee() 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, bytes calldata data) external;

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

    function skim(address to) external;

    function sync() external;
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IBlazeSwapMath {
    function sqrt(uint256 x) external pure returns (uint256 r);

    function mulDiv(uint256 x, uint256 y, uint256 z) external pure returns (uint256 r);

    function mulDivRoundingUp(uint256 x, uint256 y, uint256 z) external pure returns (uint256 r);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IDistributionToDelegators {
    function votePowerBlockNumbers(uint256 _month) external view returns (uint256[] memory);

    function getClaimableAmount(uint256 _month) external view returns (uint256 _amountWei);

    function getClaimableAmountOf(address account, uint256 _month) external view returns (uint256 _amountWei);

    function claim(address payable _recipient, uint256 _month) external returns (uint256 _amountWei);

    function getCurrentMonth() external view returns (uint256 _currentMonth);

    function getMonthToExpireNext() external view returns (uint256 _monthToExpireNext);

    function secondsTillNextClaim() external view returns (uint256 _timetill);
}
          

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

interface IBlazeSwapDelegation {
    function voteOf(address liquidityProvider) external view returns (address);

    function providerVotes(address ftsoProvider) external view returns (uint256);

    function providers(uint256 index) external view returns (address);

    function providersCount() external view returns (uint256);

    function providersAll() external view returns (address[] memory);

    function providersSubset(uint256 offset, uint256 count) external view returns (address[] memory);

    function providersWithVotes() external view returns (address[] memory, uint256[] memory);

    function providersSubsetWithVotes(
        uint256 offset,
        uint256 count
    ) external view returns (address[] memory, uint256[] memory);

    function voteFor(address provider) external;

    function currentProviders() external view returns (address[] memory, uint256[] memory);

    function providersAtCurrentEpoch() external view returns (address[] memory, uint256[] memory);

    function providersAtEpoch(uint256 epoch) external view returns (address[] memory, uint256[] memory);

    function mostVotedProviders(uint256 max) external view returns (address[] memory, uint256[] memory);

    function changeProviders(address[] memory ftsoProviders) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IERC165 {
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

enum TokenType {
    Generic,
    WNat,
    FlareAsset
}

enum FlareAssetSupport {
    None,
    Minimal,
    Full
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IFtsoManager {
    function rewardManager() external view returns (address);

    function getCurrentRewardEpoch() external view returns (uint256);

    function getRewardEpochVotePowerBlock(uint256 _rewardEpoch) external view returns (uint256);

    function getRewardEpochToExpireNext() external view returns (uint256); // not currently available on Songbird

    function rewardEpochDurationSeconds() external view returns (uint256);

    function rewardEpochs(
        uint256 _rewardEpochId
    ) external view returns (uint256 _votepowerBlock, uint256 _startBlock, uint256 _startTimestamp);
}
          

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

import './BlazeSwapERC20.sol';
import './interfaces/erc20/IERC20Snapshot.sol';

contract BlazeSwapERC20Snapshot is BlazeSwapERC20, IERC20Snapshot {
    struct Snapshot {
        uint256 id;
        uint256 value;
    }
    mapping(address => Snapshot[]) private _accountBalanceSnapshots;
    Snapshot[] private _totalSupplySnapshots;
    uint256 private _currentSnapshotId;

    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {
        _updateSnapshot(from, to);
    }

    // ERC20 Snapshot extension allowing retrieval of historical balances and total supply,
    // inspired by https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol[MiniMeToken]

    function _updateSnapshot(address from, address to) private {
        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf[account]);
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply);
    }

    function _updateSnapshot(Snapshot[] storage snapshots, uint256 currentValue) private {
        uint256 lastSnapshotId = (snapshots.length == 0) ? 0 : snapshots[snapshots.length - 1].id;
        if (lastSnapshotId < block.number) {
            Snapshot memory snapshot = Snapshot(block.number, currentValue);
            snapshots.push(snapshot);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshot[] storage snapshots) private view returns (bool, uint256) {
        require(snapshotId <= block.number, 'BlazeSwap: INVALID_SNAPSHOT_ID');

        // find the first snapshots index with id > snapshotId in O(log(n))
        uint256 low;
        uint256 high = snapshots.length;
        while (low < high) {
            uint256 mid = (low + high) / 2; // overflow is not an issue in this case
            if (snapshots[mid].id > snapshotId) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // if snapshotted, return the value
        return (low < snapshots.length) ? (true, snapshots[low].value) : (false, 0);
    }

    function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
        return snapshotted ? value : balanceOf[account];
    }

    function totalSupplyAt(uint256 snapshotId) public view returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);
        return snapshotted ? value : totalSupply;
    }
}
          

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

import './BlazeSwapBasePair.sol';
import './BlazeSwapERC20Snapshot.sol';
import './BlazeSwapMulticall.sol';

import './interfaces/flare/IFtsoManager.sol';
import './interfaces/IBlazeSwapDelegation.sol';
import './interfaces/IBlazeSwapFactory.sol';
import './interfaces/IBlazeSwapManager.sol';
import './interfaces/IBlazeSwapPair.sol';
import './interfaces/IBlazeSwapPlugin.sol';
import './interfaces/IIBlazeSwapPluginImpl.sol';
import './interfaces/IIBlazeSwapDelegation.sol';

import './libraries/BlazeSwapFlareLibrary.sol';

library BlazeSwapPairStorage {
    struct Layout {
        address token0; // duplicated for easy/local access by plugins
        address token1; // duplicated for easy/local access by plugins
        TokenType type0;
        TokenType type1;
        mapping(bytes4 => bool) supportedInterfaces;
        mapping(bytes4 => address) pluginSelector;
        address[] pluginImpls; // first for delegation, others for rewards
    }

    bytes32 internal constant STORAGE_SLOT = keccak256('blazeswap.storage.BlazeSwapPair');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

contract BlazeSwapPair is IBlazeSwapPair, BlazeSwapBasePair, BlazeSwapERC20Snapshot, BlazeSwapMulticall {
    constructor() {
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        l.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;
        l.supportedInterfaces[type(IERC165).interfaceId] = true;
        l.supportedInterfaces[type(IERC20).interfaceId] = true;
        l.supportedInterfaces[type(IERC20Metadata).interfaceId] = true;
        l.supportedInterfaces[type(IERC20Permit).interfaceId] = true;
        l.supportedInterfaces[type(IERC20Snapshot).interfaceId] = true;
        l.supportedInterfaces[type(IBlazeSwapMulticall).interfaceId] = true;
        l.supportedInterfaces[type(IBlazeSwapBasePair).interfaceId] = true;
        l.supportedInterfaces[type(IBlazeSwapPair).interfaceId] = true;
    }

    function initialize(
        address _manager,
        address _token0,
        address _token1,
        TokenType _type0,
        TokenType _type1
    ) external onlyParent {
        initialize(_manager, _token0, _token1);
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        l.token0 = _token0;
        l.token1 = _token1;
        l.type0 = _type0;
        l.type1 = _type1;
    }

    function type0() external view returns (TokenType) {
        return BlazeSwapPairStorage.layout().type0;
    }

    function type1() external view returns (TokenType) {
        return BlazeSwapPairStorage.layout().type1;
    }

    function addPlugin(address plugin) external onlyParent {
        // the factory enforces that first plugin is for delegation, while next ones are for rewards
        address impl = IBlazeSwapPlugin(plugin).implementation();
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        l.pluginImpls.push(impl);
        (bytes4[] memory selectors, bytes4 interfaceId) = IBlazeSwapPluginImpl(impl).pluginMetadata();
        for (uint256 i; i < selectors.length; i++) {
            require(l.pluginSelector[selectors[i]] == address(0));
            l.pluginSelector[selectors[i]] = impl;
        }
        FacetCut[] memory fc = new FacetCut[](1);
        fc[0] = FacetCut(impl, FacetCutAction.Add, selectors);
        bytes memory functionData = abi.encodeWithSelector(IIBlazeSwapPluginImpl.initialize.selector, plugin);
        emit DiamondCut(fc, impl, functionData);
        l.supportedInterfaces[interfaceId] = true;
        DelegateCallHelper.delegateAndCheckResult(impl, functionData);
    }

    // prettier-ignore
    fallback(bytes calldata _input) external returns (bytes memory result) {
        address plugin = BlazeSwapPairStorage.layout().pluginSelector[msg.sig];
        require(plugin != address(0), 'BlazeSwap: INVALID_FUNCTION');
        result = DelegateCallHelper.delegateAndCheckResult(plugin, _input);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override(BlazeSwapERC20, BlazeSwapERC20Snapshot) {
        super._beforeTokenTransfer(from, to, amount);
        // move votes
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        if (l.pluginImpls.length > 0) {
            address plugin = l.pluginImpls[0];
            DelegateCallHelper.delegateAndCheckResult(
                plugin,
                abi.encodeWithSelector(IIBlazeSwapDelegation.transferDelegatorVotes.selector, from, to, amount)
            );
        }
    }

    function supportsInterface(bytes4 interfaceID) external view returns (bool supported) {
        supported = BlazeSwapPairStorage.layout().supportedInterfaces[interfaceID];
    }

    function facets() external view returns (Facet[] memory facets_) {
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        uint256 length = l.pluginImpls.length;
        facets_ = new Facet[](length);
        for (uint256 i; i < length; i++) {
            address plugin = l.pluginImpls[i];
            (bytes4[] memory selectors, ) = IBlazeSwapPluginImpl(plugin).pluginMetadata();
            facets_[i] = Facet(plugin, selectors);
        }
    }

    function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_) {
        BlazeSwapPairStorage.Layout storage l = BlazeSwapPairStorage.layout();
        uint256 length = l.pluginImpls.length;
        for (uint256 i; i < length; i++) {
            if (l.pluginImpls[i] == _facet) {
                (facetFunctionSelectors_, ) = IBlazeSwapPluginImpl(_facet).pluginMetadata();
                break;
            }
        }
    }

    function facetAddresses() external view returns (address[] memory facetAddresses_) {
        facetAddresses_ = BlazeSwapPairStorage.layout().pluginImpls;
    }

    function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_) {
        facetAddress_ = BlazeSwapPairStorage.layout().pluginSelector[_functionSelector];
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

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

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import '../interfaces/flare/IDistributionTreasury.sol';
import '../interfaces/flare/IDistributionToDelegators.sol';
import '../interfaces/flare/IPriceSubmitter.sol';
import '../interfaces/flare/IFtsoManager.sol';
import '../interfaces/flare/IFtsoRewardManager.sol';
import '../interfaces/flare/IWNat.sol';

library BlazeSwapFlareLibrary {
    IPriceSubmitter private constant priceSubmitter = IPriceSubmitter(0x1000000000000000000000000000000000000003);
    IDistributionTreasury private constant distributionTreasury =
        IDistributionTreasury(0x1000000000000000000000000000000000000004);

    function getDistribution() internal view returns (IDistributionToDelegators distribution) {
        if (block.chainid == 14 || block.chainid == 114) {
            address curDistribution = distributionTreasury.selectedDistribution();
            if (curDistribution != address(0) && curDistribution == distributionTreasury.distributionToDelegators()) {
                distribution = IDistributionToDelegators(curDistribution);
            }
        }
    }

    function getFtsoManager() internal view returns (IFtsoManager) {
        return IFtsoManager(priceSubmitter.getFtsoManager());
    }

    function getFtsoRewardManager(IFtsoManager ftsoManager) internal view returns (IFtsoRewardManager) {
        return IFtsoRewardManager(ftsoManager.rewardManager());
    }

    function getWNat(IFtsoRewardManager ftsoRewardManager) internal view returns (IWNat) {
        return IWNat(ftsoRewardManager.wNat());
    }
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import './eip2535/IDiamondCut.sol';
import './eip2535/IDiamondLoupe.sol';
import './erc20/IERC20Snapshot.sol';
import './erc165/IERC165.sol';
import './IBlazeSwapBasePair.sol';
import './IBlazeSwapMulticall.sol';
import './Enumerations.sol';

interface IBlazeSwapPair is
    IBlazeSwapBasePair,
    IBlazeSwapMulticall,
    IERC20Snapshot,
    IERC165,
    IDiamondLoupe,
    IDiamondCut
{
    function type0() external view returns (TokenType);

    function type1() external view returns (TokenType);
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

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

    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 manager() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

// A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds
interface IDiamondLoupe {
    /// These functions are expected to be called frequently
    /// by tools.

    struct Facet {
        address facetAddress;
        bytes4[] functionSelectors;
    }

    /// @notice Gets all facet addresses and their four byte function selectors.
    /// @return facets_ Facet
    function facets() external view returns (Facet[] memory facets_);

    /// @notice Gets all the function selectors supported by a specific facet.
    /// @param _facet The facet address.
    /// @return facetFunctionSelectors_
    function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);

    /// @notice Get all the facet addresses used by a diamond.
    /// @return facetAddresses_
    function facetAddresses() external view returns (address[] memory facetAddresses_);

    /// @notice Gets the facet that supports the given selector.
    /// @dev If facet is not found return address(0).
    /// @param _functionSelector The function selector.
    /// @return facetAddress_ The facet address.
    function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);
}
          

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

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

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

// 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 {
    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) {
        unchecked {
            z = x / uint224(y);
        }
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IDistributionTreasury {
    function selectedDistribution() external view returns (address);

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

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IFtsoRewardManager {
    function active() external view returns (bool);

    function wNat() external view returns (address);

    function getRewardEpochToExpireNext() external view returns (uint256);

    function getEpochsWithUnclaimedRewards(address _beneficiary) external view returns (uint256[] memory _epochIds);

    function getStateOfRewards(
        address _beneficiary,
        uint256 _rewardEpoch
    )
        external
        view
        returns (
            address[] memory _dataProviders,
            uint256[] memory _rewardAmounts,
            bool[] memory _claimed,
            bool _claimable
        );

    function claimReward(
        address payable _recipient,
        uint256[] calldata _rewardEpochs
    ) external returns (uint256 _rewardAmount);

    function oldFtsoRewardManager() external view returns (address); // not currently available on Songbird

    function getUnclaimedReward(
        uint256 _rewardEpoch,
        address _dataProvider
    ) external view returns (uint256 _amount, uint256 _weight);

    function getDataProviderCurrentFeePercentage(address _dataProvider) external view returns (uint256);

    function getDataProviderScheduledFeePercentageChanges(
        address _dataProvider
    )
        external
        view
        returns (uint256[] memory _feePercentageBIPS, uint256[] memory _validFromEpoch, bool[] memory _fixed);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IConfigurable {
    function configSetter() external view returns (address);

    function setConfigSetter(address _configSetter) external;
}
          

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import './IBlazeSwapBaseFactory.sol';

interface IBlazeSwapFactory is IBlazeSwapBaseFactory {
    function isFlareAssetPairWithoutPlugin(address pair) external view returns (bool);

    function upgradeFlareAssetPair(address pair) external;
}
          

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

import './interfaces/erc20/IERC20.sol';
import './interfaces/erc20/IERC20Metadata.sol';
import './interfaces/erc20/IERC20Permit.sol';

contract BlazeSwapERC20 is IERC20, IERC20Metadata, IERC20Permit {
    string public constant name = 'BlazeSwap';
    string public constant symbol = 'BLAZE-LP';
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    uint256 private immutable CACHED_CHAIN_ID;
    bytes32 private immutable CACHED_DOMAIN_SEPARATOR;

    bytes32 public constant PERMIT_TYPEHASH =
        keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)');
    mapping(address => uint256) public nonces;

    constructor() {
        CACHED_CHAIN_ID = block.chainid;
        CACHED_DOMAIN_SEPARATOR = createDomainSeparator();
    }

    function createDomainSeparator() internal view returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
                    keccak256(bytes(name)),
                    keccak256(bytes('1')),
                    block.chainid,
                    address(this)
                )
            );
    }

    function DOMAIN_SEPARATOR() public view returns (bytes32) {
        return (CACHED_CHAIN_ID == block.chainid) ? CACHED_DOMAIN_SEPARATOR : createDomainSeparator();
    }

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

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

    function _burn(address from, uint256 value) internal {
        _beforeTokenTransfer(from, address(0), value);
        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 {
        require(to != address(0), 'BlazeSwap: ZERO_ADDRESS');
        _beforeTokenTransfer(from, to, value);
        balanceOf[from] -= value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
    }

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

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

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

    // ERC20 Permit extension allowing approvals to be made via signatures,
    // as defined in https://eips.ethereum.org/EIPS/eip-2612 [EIP-2612].

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        require(deadline >= block.timestamp, 'BlazeSwap: 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, 'BlazeSwap: INVALID_SIGNATURE');
        _approve(owner, spender, value);
    }
}
          

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

interface IBlazeSwapPluginImpl {
    function pluginMetadata() external pure returns (bytes4[] memory selectors, bytes4 interfaceId);
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library ParentRelationStorage {
    struct Layout {
        address parent;
    }

    bytes32 internal constant STORAGE_SLOT = keccak256('blazeswap.storage.ParentRelation');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

abstract contract ParentRelation {
    constructor() {
        initParentRelation(msg.sender);
    }

    function initParentRelation(address _parent) internal {
        ParentRelationStorage.layout().parent = _parent;
    }

    function checkParent() private view {
        require(ParentRelationStorage.layout().parent == msg.sender, 'ParentRelation: FORBIDDEN');
    }

    modifier onlyParent() {
        checkParent();
        _;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

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

    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.0;

import './interfaces/IBlazeSwapBaseFactory.sol';
import './BlazeSwapBasePair.sol';

contract BlazeSwapBaseFactory is IBlazeSwapBaseFactory {
    address public immutable manager;

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

    constructor(address _manager) {
        require(_manager != address(0), 'BlazeSwap: ZERO_ADDRESS');
        manager = _manager;
    }

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

    function pairCreationCode() internal pure virtual returns (bytes memory code) {
        code = type(BlazeSwapBasePair).creationCode;
    }

    function initializePair(address pair, address token0, address token1) internal virtual {
        BlazeSwapBasePair(pair).initialize(manager, token0, token1);
    }

    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, 'BlazeSwap: IDENTICAL_ADDRESSES');
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'BlazeSwap: ZERO_ADDRESS');
        require(getPair[token0][token1] == address(0), 'BlazeSwap: PAIR_EXISTS'); // single check is sufficient

        // this way to create a contract (instead of `new`) allows to use deterministic addresses
        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
        bytes memory bytecode = pairCreationCode();
        assembly {
            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        initializePair(pair, token0, token1);
        getPair[token0][token1] = pair;
        getPair[token1][token0] = pair; // populate mapping in the reverse direction
        allPairs.push(pair);
        emit PairCreated(token0, token1, pair, allPairs.length);
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.5;
pragma abicoder v2;

interface IVPToken {
    function delegatesOf(
        address _owner
    )
        external
        view
        returns (address[] memory _delegateAddresses, uint256[] memory _bips, uint256 _count, uint256 _delegationMode);

    function delegatesOfAt(
        address _who,
        uint256 _blockNumber
    )
        external
        view
        returns (address[] memory _delegateAddresses, uint256[] memory _bips, uint256 _count, uint256 _delegationMode);

    function delegate(address _to, uint256 _bips) external;

    function undelegateAll() external;

    function totalVotePowerAt(uint256 _blockNumber) external view returns (uint256);

    function batchVotePowerOfAt(
        address[] memory _owners,
        uint256 _blockNumber
    ) external view returns (uint256[] memory);
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library ReentrancyLockStorage {
    struct Layout {
        uint256 status;
    }

    bytes32 internal constant STORAGE_SLOT = keccak256('blazeswap.storage.ReentrancyLock');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

abstract contract ReentrancyLock {
    function initReentrancyLock() internal {
        ReentrancyLockStorage.layout().status = 1;
    }

    function internalLock() private {
        ReentrancyLockStorage.Layout storage l = ReentrancyLockStorage.layout();
        require(l.status != 2, 'ReentrancyLock: reentrant call');
        l.status = 2;
    }

    function internalUnlock() private {
        ReentrancyLockStorage.layout().status = 1;
    }

    modifier lock() {
        internalLock();
        _;
        internalUnlock();
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library DelegateCallHelper {
    function delegateAndCheckResult(address recipient, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory result) = recipient.delegatecall(data);

        if (!success) {
            if (result.length == 0) revert('DelegateCallHelper: revert with no reason');
            assembly {
                let result_len := mload(result)
                revert(add(32, result), result_len)
            }
        }

        return result;
    }
}
          

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

import '../shared/libraries/TransferHelper.sol';
import '../shared/ParentRelation.sol';
import '../shared/ReentrancyLock.sol';
import './interfaces/IBlazeSwapBasePair.sol';
import './interfaces/IBlazeSwapBaseManager.sol';
import './interfaces/IBlazeSwapCallee.sol';
import './interfaces/IBlazeSwapMath.sol';
import './libraries/Math.sol';
import './libraries/UQ112x112.sol';
import './BlazeSwapERC20.sol';

contract BlazeSwapBasePair is IBlazeSwapBasePair, BlazeSwapERC20, ReentrancyLock, ParentRelation {
    using UQ112x112 for uint224;
    using TransferHelper for address;

    uint256 public constant MINIMUM_LIQUIDITY = 10 ** 3;
    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));

    IBlazeSwapMath mc;

    address public manager;
    address public token0;
    address public token1;

    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 pendingFeeTotal;
    mapping(address => uint256) public pendingFeeShare;
    address[] private pendingFeeAccount;

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

    function factory() external view returns (address) {
        return ParentRelationStorage.layout().parent;
    }

    // called once by the factory at time of deployment
    function initialize(address _manager, address _token0, address _token1) public onlyParent {
        mc = IBlazeSwapMath(IBlazeSwapBaseManager(_manager).mathContext());
        manager = _manager;
        token0 = _token0;
        token1 = _token1;
    }

    // update reserves and, on the first call per block, price accumulators
    function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
        require(balance0 <= type(uint112).max && balance1 <= type(uint112).max, 'BlazeSwap: OVERFLOW');
        uint32 blockTimestamp;
        unchecked {
            blockTimestamp = uint32(block.timestamp % 2 ** 32);
            uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
            if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                // * never overflows, and + overflow is desired
                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 _wipePendingFeeData() private {
        for (uint256 i = pendingFeeAccount.length; i > 0; i--) {
            address splitFeeRecipient = pendingFeeAccount[i - 1];
            pendingFeeShare[splitFeeRecipient] = 0;
            pendingFeeAccount.pop();
        }
        pendingFeeTotal = 0;
    }

    // if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
        address feeTo = IBlazeSwapBaseManager(manager).tradingFeeTo();
        feeOn = feeTo != address(0);
        uint256 _kLast = kLast; // gas savings
        if (feeOn) {
            if (_kLast != 0) {
                uint256 rootK = mc.sqrt(uint256(_reserve0) * _reserve1);
                uint256 rootKLast = mc.sqrt(_kLast);
                if (rootK > rootKLast) {
                    uint256 numerator = totalSupply * (rootK - rootKLast);
                    uint256 denominator = rootK * 5 + rootKLast;
                    uint256 liquidity = numerator / denominator;
                    if (liquidity > 0) {
                        for (uint256 i; i < pendingFeeAccount.length; i++) {
                            address splitFeeRecipient = pendingFeeAccount[i];
                            uint256 splitFeeLiquidity = mc.mulDiv(
                                liquidity,
                                pendingFeeShare[splitFeeRecipient],
                                pendingFeeTotal
                            );
                            if (splitFeeLiquidity > 0) {
                                _mint(splitFeeRecipient, splitFeeLiquidity);
                                liquidity -= splitFeeLiquidity;
                            }
                        }
                        if (liquidity > 0) {
                            _mint(feeTo, liquidity);
                        }
                    }
                }
                _wipePendingFeeData();
            }
        } else if (_kLast != 0) {
            kLast = 0;
            _wipePendingFeeData();
        }
    }

    function mintFee() external {
        (uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
        bool feeOn = _mintFee(_reserve0, _reserve1);
        if (feeOn) kLast = uint256(_reserve0) * _reserve1;
    }

    // this low-level function should be called from a contract which performs important safety checks
    function mint(address to) external lock 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;

        bool feeOn = _mintFee(_reserve0, _reserve1);
        uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
        if (_totalSupply == 0) {
            liquidity = mc.sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
            _mint(address(0x000000000000000000000000000000000000dEaD), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
        } else {
            liquidity = Math.min((amount0 * _totalSupply) / _reserve0, (amount1 * _totalSupply) / _reserve1);
        }
        require(liquidity > 0, 'BlazeSwap: INSUFFICIENT_LIQUIDITY_MINTED');
        _mint(to, liquidity);

        _update(balance0, balance1, _reserve0, _reserve1);
        unchecked {
            if (feeOn) kLast = uint256(reserve0) * reserve1; // reserve0 and reserve1 are up-to-date
        }
        emit Mint(msg.sender, amount0, amount1);
    }

    // this low-level function should be called from a contract which performs important safety checks
    function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
        (uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
        address _token0 = token0; // gas savings
        address _token1 = token1; // gas savings
        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; // gas savings, must be defined here since totalSupply can update in _mintFee
        amount0 = (liquidity * balance0) / _totalSupply; // using balances ensures pro-rata distribution
        amount1 = (liquidity * balance1) / _totalSupply; // using balances ensures pro-rata distribution
        require(amount0 > 0 && amount1 > 0, 'BlazeSwap: INSUFFICIENT_LIQUIDITY_BURNED');
        _burn(address(this), liquidity);
        _token0.safeTransfer(to, amount0);
        _token1.safeTransfer(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; // reserve0 and reserve1 are up-to-date
        emit Burn(msg.sender, amount0, amount1, to);
    }

    function _recordSwapFees(uint112 oldReserve0, uint112 oldReserve1, bool splitFee) private {
        if (kLast != 0) {
            (uint112 newReserve0, uint112 newReserve1, ) = getReserves();
            uint256 feeShare = uint256(newReserve0) * newReserve1 - uint256(oldReserve0) * oldReserve1;
            pendingFeeTotal += feeShare;
            if (splitFee) {
                (address splitFeeRecipient, uint256 splitFeeBips) = IBlazeSwapBaseManager(manager).getTradingFeeSplit(
                    msg.sender
                );
                if (splitFeeRecipient != address(0) && splitFeeBips > 0) {
                    uint256 splitFeeShare = (feeShare * splitFeeBips) / 100_00;
                    if (feeShare > 0) {
                        uint256 oldFeeShare = pendingFeeShare[splitFeeRecipient];
                        if (oldFeeShare == 0) {
                            pendingFeeAccount.push(splitFeeRecipient);
                        }
                        pendingFeeShare[splitFeeRecipient] += splitFeeShare;
                    }
                }
            }
        }
    }

    function splitFeeSwap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external {
        (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
        swapInternal(_reserve0, reserve1, amount0Out, amount1Out, to, data);
        _recordSwapFees(_reserve0, _reserve1, true);
    }

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external {
        (uint112 _reserve0, uint112 _reserve1, ) = getReserves();
        swapInternal(_reserve0, reserve1, amount0Out, amount1Out, to, data);
        _recordSwapFees(_reserve0, _reserve1, false);
    }

    // this low-level function should be called from a contract which performs important safety checks
    function swapInternal(
        uint112 _reserve0,
        uint112 _reserve1,
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) internal lock {
        require(amount0Out > 0 || amount1Out > 0, 'BlazeSwap: INSUFFICIENT_OUTPUT_AMOUNT');
        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'BlazeSwap: 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, 'BlazeSwap: INVALID_TO');
            if (amount0Out > 0) _token0.safeTransfer(to, amount0Out);
            // optimistically transfer tokens
            if (amount1Out > 0) _token1.safeTransfer(to, amount1Out);
            // optimistically transfer tokens
            if (data.length > 0) IBlazeSwapCallee(to).blazeSwapCall(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, 'BlazeSwap: INSUFFICIENT_INPUT_AMOUNT');
        {
            // scope for reserve{0,1}Adjusted, avoids stack too deep errors
            uint256 balance0Adjusted = balance0 * 1000 - amount0In * 3;
            uint256 balance1Adjusted = balance1 * 1000 - amount1In * 3;
            require(balance0Adjusted * balance1Adjusted >= uint256(_reserve0) * _reserve1 * 1000 ** 2, 'BlazeSwap: K');
        }
        _update(balance0, balance1, _reserve0, _reserve1);
        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
    }

    // force balances to match reserves
    function skim(address to) external lock {
        address _token0 = token0; // gas savings
        address _token1 = token1; // gas savings
        _token0.safeTransfer(to, IERC20(_token0).balanceOf(address(this)) - reserve0);
        _token1.safeTransfer(to, IERC20(_token1).balanceOf(address(this)) - reserve1);
    }

    // force reserves to match balances
    function sync() external lock {
        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
    }
}