Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

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

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "./DeltaBRC20PoolProxy.sol";
import "../interfaces/IDeltaPool.sol";
import "../interfaces/IDeltaPoolController.sol";

contract DeltaBRC20PoolController is Ownable, IDeltaPoolController {
    bool private initialized;

    address[] public pools;
    address public poolImplementation;
    address public poolAdmin;
    address public devAddress;

    uint256[] public levelOfStakeCounts;
    uint256[] public defaultShareAllocRulers; // base  100000
    uint256 public maxLevel; // 1 - 5

    event PoolCreated(
        address pool,
        address[5] args1,
        uint256[6] args2,
        IDeltaNFT.UnlockArgs unlockArgs
    );

    event PoolImplementationUpdated(address poolImplementation);
    event PoolCreated(address pool);
    event SetShareAlloc(uint256 level, uint val);
    event SetLevelOfPower(uint256 level, uint val);

    event DevAddressUpdated(address devAddress);

    function initialize(
        address _owner,
        address _devAddress,
        address _poolImplementation,
        address _poolAdmin,
        uint256[] memory stakeAmounts,
        uint256[] memory shareAllocs
    ) external {
        require(!initialized, "initialize: Already initialized!");
        _transferOwnership(_owner);
        devAddress = _devAddress;
        poolImplementation = _poolImplementation;
        poolAdmin = _poolAdmin;

        for (uint256 i = 0; i < stakeAmounts.length; i++) {
            levelOfStakeCounts.push(stakeAmounts[i]);
        }

        for (uint256 i = 0; i < shareAllocs.length; i++) {
            defaultShareAllocRulers.push(shareAllocs[i]);
        }

        maxLevel = levelOfStakeCounts.length;
        initialized = true;
    }

    function updatePoolImplementation(
        address _poolImplementation
    ) external onlyOwner {
        poolImplementation = _poolImplementation;
        emit PoolImplementationUpdated(_poolImplementation);
    }

    function createPoolProxy(
        address[5] calldata args1,
        uint256[6] calldata args2,
        IDeltaNFT.UnlockArgs calldata _unlockArgs,
        bytes32 _merkleRoot
    ) external onlyOwner {
        DeltaBRC20PoolProxy pool = new DeltaBRC20PoolProxy(
            poolImplementation,
            poolAdmin,
            abi.encodeWithSignature(
                "initialize(address[5],uint256[6])",
                args1,
                args2
            )
        );

        address poolAddress = address(pool);

        IDeltaNFT(args1[4]).grantRole(
            keccak256(bytes("ROLE_MINTER")),
            poolAddress
        );

        IDeltaPool(poolAddress).setUnlockArgsAddRoot(_unlockArgs, _merkleRoot);
        pools.push(poolAddress);
        emit PoolCreated(poolAddress, args1, args2, _unlockArgs);
    }

    function setShareAlloc(uint256 level, uint val) external onlyOwner {
        require(level < maxLevel, "error level");
        defaultShareAllocRulers[level] = val;
        emit SetShareAlloc(level, val);
    }

    function getShareAlloc(
        uint256 level
    ) external view override returns (uint256) {
        require(level < maxLevel, "error level");
        return defaultShareAllocRulers[level];
    }

    function setLevelOfPower(
        uint256 levelBorder,
        uint borderValue
    ) external onlyOwner {
        require(levelBorder < maxLevel, "error border");
        levelOfStakeCounts[levelBorder] = borderValue;
        emit SetLevelOfPower(levelBorder, borderValue);
    }

    function getLevelByAmount(
        uint256 stakeAmount
    ) external view override returns (uint256) {
        if (stakeAmount < levelOfStakeCounts[0]) {
            return 0;
        } else {
            for (uint256 i = maxLevel - 1; i > 0; i--) {
                if (stakeAmount >= levelOfStakeCounts[i]) {
                    return i + 1;
                }
            }
        }
        return 1;
    }

    function updatedDevAddress(address _devAddress) external onlyOwner {
        devAddress = _devAddress;
        emit DevAddressUpdated(_devAddress);
    }

    function getDevAddress() external view override returns (address) {
        return devAddress;
    }

    function getMaxLevel() external view override returns (uint256) {
        return maxLevel;
    }

    function allPoolsOf(uint256 index) external view returns (address) {
        return pools[index];
    }

    function allPoolsOfLength() external view returns (uint256) {
        return pools.length;
    }
}

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

/**
 * @title IDeltaPoolController
 * @dev IDeltaPoolController interface
 * create stakePool
 */
interface IDeltaPoolController {
    /**
     * @dev developer wallet address
     */
    function getDevAddress() external view returns (address);

    /*
     * @dev get level by stake amount
     * @param stakeAmount stake amount
     * @return  level
     */
    function getLevelByAmount(
        uint256 stakeAmount
    ) external view returns (uint256);

    /*
     * @dev get max vip level
     * @return max vip level
     */
    function getMaxLevel() external view returns (uint256);

    /*
     * @dev get share alloc
     * @param level user level
     * @return share alloc
     */
    function getShareAlloc(uint256 level) external view returns (uint256);
}

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

import "./IDeltaNFT.sol";

/**
 * @title IDeltaPool
 * @dev IDeltaPool interface
 * stakePool
 */
interface IDeltaPool {
    function initialize(
        address[5] calldata args1,
        uint256[6] calldata args2
    ) external returns (address poolAddress);

    function setUnlockArgsAddRoot(
        IDeltaNFT.UnlockArgs calldata _unlockArgs,
        bytes32 _merkleRoot
    ) external;

    function getUnlockArgs()
        external
        view
        returns (
            uint256 firstReleaseTime,
            uint256 firstBalance,
            uint256 remainingUnlockedType,
            uint256[4] memory remainingUnlocked,
            uint256 totalBalance
        );

    function subOffer(
        uint256 senderIndex,
        address account,
        uint256 amount,
        bytes32[] memory merkleProof
    ) external payable returns (uint256 level, uint256 index);

    function isLuckyDog(address user) external view returns (bool);

    function refund() external;

    function draw() external;

    function unlockToken(
        uint256 tokenId
    ) external returns (uint256 amount, uint256 _tokenId);
}

pragma solidity ^0.8.0;

// SPDX-License-Identifier: MIT

import "../proxy/transparent/TransparentUpgradeableProxy.sol";

contract DeltaBRC20PoolProxy is TransparentUpgradeableProxy {
    constructor(
        address _implementation,
        address _admin,
        bytes memory _data
    ) TransparentUpgradeableProxy(_implementation, _admin, _data) {}

    // Allow anyone to view the implementation address
    function proxyImplementation() external view returns (address) {
        return _implementation();
    }

    function proxyAdmin() external view returns (address) {
        return _admin();
    }
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.6;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/IAccessControl.sol";

interface IDeltaNFT is IAccessControl, IERC721 {
    /**
     * @param firstReleaseTime
     * @param firstBalance  
     * @param remainingUnlockedType [0|1|2]
     * @args: type == 0: direct type args = [startTime, 0],
     *        type == 1: linear type args = [startTime, endTime, 0]
              type == 2: period type args = [startTime, interval, stepBalance, 0]
     */
    struct UnlockArgs {
        uint256 firstReleaseTime;
        uint256 firstBalance;
        uint256 remainingUnlockedType;
        uint256[4] remainingUnlocked;
        uint256 totalBalance;
    }

    struct TargetArgs {
        address targetToken;
        address poolAddress;
    }

    function mintNFT(
        address to,
        UnlockArgs calldata unlockArgs,
        TargetArgs calldata targetArgs
    ) external returns (uint256 tokenId);

    function getTokenUnlockArgs(
        uint256 tokenId
    )
        external
        view
        returns (
            uint256 firstReleaseTime,
            uint256 firstBalance,
            uint256 remainingUnlockedType,
            uint256[4] calldata remainingUnlocked,
            uint256 totalBalance
        );

    function getTokenTargetToken(
        uint256 tokenId
    ) external view returns (address targetToken, address poolAddress);

    function burnNFT(uint256 tokenId) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)

pragma solidity ^0.8.0;

import "../ERC1967/ERC1967Proxy.sol";

/**
 * @dev This contract implements a proxy that is upgradeable by an admin.
 *
 * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
 * clashing], which can potentially be used in an attack, this contract uses the
 * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
 * things that go hand in hand:
 *
 * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
 * that call matches one of the admin functions exposed by the proxy itself.
 * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
 * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
 * "admin cannot fallback to proxy target".
 *
 * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
 * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
 * to sudden errors when trying to call a function from the proxy implementation.
 *
 * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
 * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
 */
contract TransparentUpgradeableProxy is ERC1967Proxy {
    /**
     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
     * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
     */
    constructor(
        address _logic,
        address admin_,
        bytes memory _data
    ) payable ERC1967Proxy(_logic, _data) {
        _changeAdmin(admin_);
    }

    /**
     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
     */
    modifier ifAdmin() {
        if (msg.sender == _getAdmin()) {
            _;
        } else {
            _fallback();
        }
    }

    /**
     * @dev Returns the current admin.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    function admin() external ifAdmin returns (address admin_) {
        admin_ = _getAdmin();
    }

    /**
     * @dev Returns the current implementation.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
     */
    function implementation()
        external
        ifAdmin
        returns (address implementation_)
    {
        implementation_ = _implementation();
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
     */
    function changeAdmin(address newAdmin) external virtual ifAdmin {
        _changeAdmin(newAdmin);
    }

    /**
     * @dev Upgrade the implementation of the proxy.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
     */
    function upgradeTo(address newImplementation) external ifAdmin {
        _upgradeToAndCall(newImplementation, bytes(""), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
     * proxied contract.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
     */
    function upgradeToAndCall(
        address newImplementation,
        bytes calldata data
    ) external payable ifAdmin {
        _upgradeToAndCall(newImplementation, data, true);
    }

    /**
     * @dev Returns the current admin.
     */
    function _admin() internal view virtual returns (address) {
        return _getAdmin();
    }

    /**
     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
     */
    function _beforeFallback() internal virtual override {
        require(
            msg.sender != _getAdmin(),
            "TransparentUpgradeableProxy: admin cannot fallback to proxy target"
        );
        super._beforeFallback();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)

pragma solidity ^0.8.0;

import "../Proxy.sol";
import "./ERC1967Upgrade.sol";

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializing the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        _upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation()
        internal
        view
        virtual
        override
        returns (address impl)
    {
        return ERC1967Upgrade._getImplementation();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../library/Address.sol";
import "../../library/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT =
        0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(
            Address.isContract(newImplementation),
            "ERC1967: new implementation is not a contract"
        );
        StorageSlot
            .getAddressSlot(_IMPLEMENTATION_SLOT)
            .value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (
                bytes32 slot
            ) {
                require(
                    slot == _IMPLEMENTATION_SLOT,
                    "ERC1967Upgrade: unsupported proxiableUUID"
                );
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT =
        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(
            newAdmin != address(0),
            "ERC1967: new admin is the zero address"
        );
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT =
        0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(
            Address.isContract(newBeacon),
            "ERC1967: new beacon is not a contract"
        );
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(
                IBeacon(newBeacon).implementation(),
                data
            );
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overridden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                0,
                "Address: low-level call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data
    ) internal view returns (bytes memory) {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(
        bytes memory returndata,
        string memory errorMessage
    ) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"devAddress","type":"address"}],"name":"DevAddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"address[5]","name":"args1","type":"address[5]"},{"indexed":false,"internalType":"uint256[6]","name":"args2","type":"uint256[6]"},{"components":[{"internalType":"uint256","name":"firstReleaseTime","type":"uint256"},{"internalType":"uint256","name":"firstBalance","type":"uint256"},{"internalType":"uint256","name":"remainingUnlockedType","type":"uint256"},{"internalType":"uint256[4]","name":"remainingUnlocked","type":"uint256[4]"},{"internalType":"uint256","name":"totalBalance","type":"uint256"}],"indexed":false,"internalType":"struct IDeltaNFT.UnlockArgs","name":"unlockArgs","type":"tuple"}],"name":"PoolCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"PoolCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"poolImplementation","type":"address"}],"name":"PoolImplementationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"level","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"val","type":"uint256"}],"name":"SetLevelOfPower","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"level","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"val","type":"uint256"}],"name":"SetShareAlloc","type":"event"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"allPoolsOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allPoolsOfLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[5]","name":"args1","type":"address[5]"},{"internalType":"uint256[6]","name":"args2","type":"uint256[6]"},{"components":[{"internalType":"uint256","name":"firstReleaseTime","type":"uint256"},{"internalType":"uint256","name":"firstBalance","type":"uint256"},{"internalType":"uint256","name":"remainingUnlockedType","type":"uint256"},{"internalType":"uint256[4]","name":"remainingUnlocked","type":"uint256[4]"},{"internalType":"uint256","name":"totalBalance","type":"uint256"}],"internalType":"struct IDeltaNFT.UnlockArgs","name":"_unlockArgs","type":"tuple"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"createPoolProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"defaultShareAllocRulers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDevAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"stakeAmount","type":"uint256"}],"name":"getLevelByAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"level","type":"uint256"}],"name":"getShareAlloc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_poolImplementation","type":"address"},{"internalType":"address","name":"_poolAdmin","type":"address"},{"internalType":"uint256[]","name":"stakeAmounts","type":"uint256[]"},{"internalType":"uint256[]","name":"shareAllocs","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"levelOfStakeCounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"pools","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"levelBorder","type":"uint256"},{"internalType":"uint256","name":"borderValue","type":"uint256"}],"name":"setLevelOfPower","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"level","type":"uint256"},{"internalType":"uint256","name":"val","type":"uint256"}],"name":"setShareAlloc","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_poolImplementation","type":"address"}],"name":"updatePoolImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"updatedDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

235:4314:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1800:214;;;;;;:::i;:::-;;:::i;:::-;;4240:96;4321:8;;4240:96;;;529:25:18;;;517:2;502:18;4240:96:5;;;;;;;;436:25;;;;;-1:-1:-1;;;;;436:25:5;;;;;;-1:-1:-1;;;;;729:32:18;;;711:51;;699:2;684:18;436:25:5;565:203:18;468:35:5;;;;;;:::i;:::-;;:::i;3559:410::-;;;;;;:::i;:::-;;:::i;2020:828::-;;;;;;:::i;:::-;;:::i;1824:101:1:-;;;:::i;3273:280:5:-;;;;;;:::i;:::-;;:::i;3975:153::-;;;;;;:::i;:::-;;:::i;4342:103::-;;;;;;:::i;:::-;;:::i;1201:85:1:-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:1;1201:85;;509:40:5;;;;;;:::i;:::-;;:::i;339:22::-;;;;;;:::i;:::-;;:::i;406:24::-;;;;;-1:-1:-1;;;;;406:24:5;;;4451:96;4528:5;:12;4451:96;;571:23;;;;;;367:33;;;;;-1:-1:-1;;;;;367:33:5;;;3070:197;;;;;;:::i;:::-;;:::i;4134:100::-;4217:10;;-1:-1:-1;;;;;4217:10:5;4134:100;;2854:210;;;;;;:::i;:::-;;:::i;1010:784::-;;;;;;:::i;:::-;;:::i;2074:198:1:-;;;;;;:::i;:::-;;:::i;1800:214:5:-;1094:13:1;:11;:13::i;:::-;1906:18:5::1;:40:::0;;-1:-1:-1;;;;;;1906:40:5::1;-1:-1:-1::0;;;;;1906:40:5;::::1;::::0;;::::1;::::0;;;1961:46:::1;::::0;711:51:18;;;1961:46:5::1;::::0;699:2:18;684:18;1961:46:5::1;;;;;;;;1800:214:::0;:::o;468:35::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;468:35:5;:::o;3559:410::-;3652:7;3689:18;3708:1;3689:21;;;;;;;;:::i;:::-;;;;;;;;;3675:11;:35;3671:274;;;-1:-1:-1;3733:1:5;;3559:410;-1:-1:-1;3559:410:5:o;3671:274::-;3770:9;3793:1;3782:8;;:12;;;;:::i;:::-;3770:24;;3765:170;3796:5;;3765:170;;3845:18;3864:1;3845:21;;;;;;;;:::i;:::-;;;;;;;;;3830:11;:36;3826:95;;3897:5;:1;3901;3897:5;:::i;:::-;3890:12;3559:410;-1:-1:-1;;;3559:410:5:o;3826:95::-;3803:3;;;;:::i;:::-;;;;3765:170;;;;-1:-1:-1;3961:1:5;;3559:410;-1:-1:-1;3559:410:5:o;2020:828::-;1094:13:1;:11;:13::i;:::-;2294:18:5::1;::::0;2326:9:::1;::::0;2349:136:::1;::::0;2230:24:::1;::::0;-1:-1:-1;;;;;2294:18:5;;::::1;::::0;2326:9:::1;::::0;2349:136:::1;::::0;2443:5;;2466;;2349:136:::1;;;:::i;:::-;;::::0;;-1:-1:-1;;2349:136:5;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;2349:136:5::1;-1:-1:-1::0;;;2349:136:5::1;::::0;;2257:238;::::1;::::0;::::1;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;2230:265:5;-1:-1:-1;2230:265:5;2562:8:::1;::::0;;;;;::::1;;:::i;:::-;2605:20;::::0;;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;2605:20:5::1;::::0;;::::1;::::0;2552:109;-1:-1:-1;;;2552:109:5;;2595:31;2552:109:::1;::::0;::::1;6149:25:18::0;-1:-1:-1;;;;;6210:32:18;;;6190:18;;;6183:60;2552:29:5;;;::::1;::::0;::::1;::::0;6122:18:18;;2552:109:5::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2672:70:5::1;::::0;-1:-1:-1;;;2672:70:5;;-1:-1:-1;;;;;2672:44:5;::::1;::::0;-1:-1:-1;2672:44:5::1;::::0;-1:-1:-1;2672:70:5::1;::::0;2717:11;;2730;;2672:70:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2752:5:5::1;:23:::0;;;;::::1;::::0;;-1:-1:-1;2752:23:5;;;;;::::1;::::0;;-1:-1:-1;;;;;;2752:23:5::1;-1:-1:-1::0;;;;;2752:23:5;::::1;;::::0;;-1:-1:-1;;2790:51:5::1;::::0;::::1;::::0;::::1;::::0;2752:23;;2815:5;;2822;;2829:11;;2790:51:::1;:::i;:::-;;;;;;;;2220:628;;2020:828:::0;;;;:::o;1824:101:1:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;:::-;1824:101::o:0;3273:280:5:-;1094:13:1;:11;:13::i;:::-;3410:8:5::1;;3396:11;:22;3388:47;;;::::0;-1:-1:-1;;;3388:47:5;;7809:2:18;3388:47:5::1;::::0;::::1;7791:21:18::0;7848:2;7828:18;;;7821:30;-1:-1:-1;;;7867:18:18;;;7860:42;7919:18;;3388:47:5::1;;;;;;;;;3479:11;3445:18;3464:11;3445:31;;;;;;;;:::i;:::-;;;;;;;;:45;;;;3505:41;3521:11;3534;3505:41;;;;;;8122:25:18::0;;;8178:2;8163:18;;8156:34;8110:2;8095:18;;7948:248;3505:41:5::1;;;;;;;;3273:280:::0;;:::o;3975:153::-;1094:13:1;:11;:13::i;:::-;4052:10:5::1;:24:::0;;-1:-1:-1;;;;;;4052:24:5::1;-1:-1:-1::0;;;;;4052:24:5;::::1;::::0;;::::1;::::0;;;4091:30:::1;::::0;711:51:18;;;4091:30:5::1;::::0;699:2:18;684:18;4091:30:5::1;565:203:18::0;4342:103:5;4400:7;4426:5;4432;4426:12;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;4426:12:5;;4342:103;-1:-1:-1;;4342:103:5:o;509:40::-;;;;;;;;;;;;339:22;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;339:22:5;;-1:-1:-1;339:22:5;:::o;3070:197::-;3154:7;3189:8;;3181:5;:16;3173:40;;;;-1:-1:-1;;;3173:40:5;;8403:2:18;3173:40:5;;;8385:21:18;8442:2;8422:18;;;8415:30;-1:-1:-1;;;8461:18:18;;;8454:41;8512:18;;3173:40:5;8201:335:18;3173:40:5;3230:23;3254:5;3230:30;;;;;;;;:::i;:::-;;;;;;;;;3223:37;;3070:197;;;:::o;2854:210::-;1094:13:1;:11;:13::i;:::-;2947:8:5::1;;2939:5;:16;2931:40;;;::::0;-1:-1:-1;;;2931:40:5;;8403:2:18;2931:40:5::1;::::0;::::1;8385:21:18::0;8442:2;8422:18;;;8415:30;-1:-1:-1;;;8461:18:18;;;8454:41;8512:18;;2931:40:5::1;8201:335:18::0;2931:40:5::1;3014:3;2981:23;3005:5;2981:30;;;;;;;;:::i;:::-;;;;;;;;:36;;;;3032:25;3046:5;3053:3;3032:25;;;;;;8122::18::0;;;8178:2;8163:18;;8156:34;8110:2;8095:18;;7948:248;1010:784:5;1259:11;;-1:-1:-1;;;1259:11:5;;;;1258:12;1250:57;;;;-1:-1:-1;;;1250:57:5;;8743:2:18;1250:57:5;;;8725:21:18;;;8762:18;;;8755:30;8821:34;8801:18;;;8794:62;8873:18;;1250:57:5;8541:356:18;1250:57:5;1317:26;1336:6;1317:18;:26::i;:::-;1353:10;:24;;-1:-1:-1;;;;;1353:24:5;;;-1:-1:-1;;;;;;1353:24:5;;;;;;;1387:18;:40;;;;;;;;;;;1437:9;:22;;;;;;;;;;;;;;;1353:10;1470:115;1494:12;:19;1490:1;:23;1470:115;;;1534:18;1558:12;1571:1;1558:15;;;;;;;;:::i;:::-;;;;;;;;;;;;1534:40;;;;;;;-1:-1:-1;1534:40:5;;;;;;;;;1515:3;;;;:::i;:::-;;;;1470:115;;;;1600:9;1595:118;1619:11;:18;1615:1;:22;1595:118;;;1658:23;1687:11;1699:1;1687:14;;;;;;;;:::i;:::-;;;;;;;;;;;;1658:44;;;;;;;-1:-1:-1;1658:44:5;;;;;;;;;1639:3;;;;:::i;:::-;;;;1595:118;;;-1:-1:-1;;1734:18:5;:25;1723:8;:36;-1:-1:-1;;;1769:18:5;;-1:-1:-1;;;;1769:18:5;-1:-1:-1;;;1769:18:5;;;-1:-1:-1;;;1010:784:5:o;2074:198:1:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2162:22:1;::::1;2154:73;;;::::0;-1:-1:-1;;;2154:73:1;;9244:2:18;2154:73:1::1;::::0;::::1;9226:21:18::0;9283:2;9263:18;;;9256:30;9322:34;9302:18;;;9295:62;-1:-1:-1;;;9373:18:18;;;9366:36;9419:19;;2154:73:1::1;9042:402:18::0;2154:73:1::1;2237:28;2256:8;2237:18;:28::i;:::-;2074:198:::0;:::o;1359:130::-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:1;719:10:3;1422:23:1;1414:68;;;;-1:-1:-1;;;1414:68:1;;9651:2:18;1414:68:1;;;9633:21:18;;;9670:18;;;9663:30;9729:34;9709:18;;;9702:62;9781:18;;1414:68:1;9449:356:18;2426:187:1;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:1;;;-1:-1:-1;;;;;;2534:17:1;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;-1:-1:-1:-;;;;;;;;:::o;14:173:18:-;82:20;;-1:-1:-1;;;;;131:31:18;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;773:180::-;832:6;885:2;873:9;864:7;860:23;856:32;853:52;;;901:1;898;891:12;853:52;-1:-1:-1;924:23:18;;773:180;-1:-1:-1;773:180:18:o;958:632::-;1123:6;1131;1139;1147;1191:9;1182:7;1178:23;1221:3;1217:2;1213:12;1210:32;;;1238:1;1235;1228:12;1210:32;1276:3;1265:9;1261:19;1299:7;1295:2;1292:15;1289:35;;;1320:1;1317;1310:12;1289:35;1343:9;1333:19;;1386:3;1375:9;1371:19;1409:7;1405:2;1402:15;1399:35;;;1430:1;1427;1420:12;1399:35;1453:2;1443:12;;1490:3;1483;1479:8;1475:2;1471:17;1467:27;1464:47;;;1507:1;1504;1497:12;1464:47;958:632;;;;-1:-1:-1;1530:2:18;;1579:3;1564:19;1551:33;;-1:-1:-1;;;;958:632:18:o;1595:248::-;1663:6;1671;1724:2;1712:9;1703:7;1699:23;1695:32;1692:52;;;1740:1;1737;1730:12;1692:52;-1:-1:-1;;1763:23:18;;;1833:2;1818:18;;;1805:32;;-1:-1:-1;1595:248:18:o;1848:127::-;1909:10;1904:3;1900:20;1897:1;1890:31;1940:4;1937:1;1930:15;1964:4;1961:1;1954:15;1980:902;2034:5;2087:3;2080:4;2072:6;2068:17;2064:27;2054:55;;2105:1;2102;2095:12;2054:55;2141:6;2128:20;2167:4;2190:18;2227:2;2223;2220:10;2217:36;;;2233:18;;:::i;:::-;2279:2;2276:1;2272:10;2311:2;2305:9;2374:2;2370:7;2365:2;2361;2357:11;2353:25;2345:6;2341:38;2429:6;2417:10;2414:22;2409:2;2397:10;2394:18;2391:46;2388:72;;;2440:18;;:::i;:::-;2476:2;2469:22;2526:18;;;2602:15;;;2598:24;;;2560:15;;;;-1:-1:-1;2634:15:18;;;2631:35;;;2662:1;2659;2652:12;2631:35;2698:2;2690:6;2686:15;2675:26;;2710:142;2726:6;2721:3;2718:15;2710:142;;;2792:17;;2780:30;;2830:12;;;;2743;;;;2710:142;;;2870:6;1980:902;-1:-1:-1;;;;;;;1980:902:18:o;2887:894::-;3041:6;3049;3057;3065;3073;3081;3134:3;3122:9;3113:7;3109:23;3105:33;3102:53;;;3151:1;3148;3141:12;3102:53;3174:29;3193:9;3174:29;:::i;:::-;3164:39;;3222:38;3256:2;3245:9;3241:18;3222:38;:::i;:::-;3212:48;;3279:38;3313:2;3302:9;3298:18;3279:38;:::i;:::-;3269:48;;3336:38;3370:2;3359:9;3355:18;3336:38;:::i;:::-;3326:48;;3425:3;3414:9;3410:19;3397:33;3449:18;3490:2;3482:6;3479:14;3476:34;;;3506:1;3503;3496:12;3476:34;3529:61;3582:7;3573:6;3562:9;3558:22;3529:61;:::i;:::-;3519:71;;3643:3;3632:9;3628:19;3615:33;3599:49;;3673:2;3663:8;3660:16;3657:36;;;3689:1;3686;3679:12;3657:36;;3712:63;3767:7;3756:8;3745:9;3741:24;3712:63;:::i;:::-;3702:73;;;2887:894;;;;;;;;:::o;3786:127::-;3847:10;3842:3;3838:20;3835:1;3828:31;3878:4;3875:1;3868:15;3902:4;3899:1;3892:15;3918:127;3979:10;3974:3;3970:20;3967:1;3960:31;4010:4;4007:1;4000:15;4034:4;4031:1;4024:15;4050:128;4117:9;;;4138:11;;;4135:37;;;4152:18;;:::i;:::-;4050:128;;;;:::o;4183:125::-;4248:9;;;4269:10;;;4266:36;;;4282:18;;:::i;4313:136::-;4352:3;4380:5;4370:39;;4389:18;;:::i;:::-;-1:-1:-1;;;4425:18:18;;4313:136::o;4454:374::-;4556:5;4579:1;4589:233;4603:4;4600:1;4597:11;4589:233;;;-1:-1:-1;;;;;4666:26:18;4685:6;4666:26;:::i;:::-;4662:52;4650:65;;4738:4;4762:12;;;;4797:15;;;;;4623:1;4616:9;4589:233;;;4593:3;;4454:374;;:::o;4833:385::-;5091:3;5076:19;;5104:52;5080:9;5138:6;5104:52;:::i;:::-;5207:4;5199:6;5193:3;5182:9;5178:19;5165:47;4833:385;;;;;:::o;5223:747::-;5389:4;5435:1;5431;5426:3;5422:11;5418:19;5476:2;5468:6;5464:15;5453:9;5446:34;5499:2;5549;5541:6;5537:15;5532:2;5521:9;5517:18;5510:43;5589:2;5584;5573:9;5569:18;5562:30;5621:6;5615:13;5601:27;;5664:6;5659:2;5648:9;5644:18;5637:34;5689:1;5699:141;5713:6;5710:1;5707:13;5699:141;;;5809:14;;;5805:23;;5799:30;5774:17;;;5793:3;5770:27;5763:67;5728:10;;5699:141;;;5703:3;;5890:1;5884:3;5875:6;5864:9;5860:22;5856:32;5849:43;5960:3;5953:2;5949:7;5944:2;5936:6;5932:15;5928:29;5917:9;5913:45;5909:55;5901:63;;;5223:747;;;;;;:::o;6254:361::-;6352:5;6339:19;6334:3;6327:32;6415:4;6408:5;6404:16;6391:30;6384:4;6379:3;6375:14;6368:54;6478:4;6471:5;6467:16;6454:30;6447:4;6442:3;6438:14;6431:54;6541:4;6534;6527:5;6523:16;6516:4;6511:3;6507:14;6494:52;6602:4;6591:16;;;6578:30;6562:14;;6555:54;6254:361::o;6620:337::-;6838:3;6823:19;;6851:56;6827:9;6889:6;6851:56;:::i;:::-;6944:6;6938:3;6927:9;6923:19;6916:35;6620:337;;;;;:::o;6962:640::-;-1:-1:-1;;;;;7363:32:18;;7345:51;;7332:3;7317:19;;7405:61;7462:2;7447:18;;7439:6;7405:61;:::i;:::-;7517:3;7509:6;7503:3;7492:9;7488:19;7475:46;7530:66;7591:3;7580:9;7576:19;7568:6;7530:66;:::i;:::-;6962:640;;;;;;;:::o;8902:135::-;8941:3;8962:17;;;8959:43;;8982:18;;:::i;:::-;-1:-1:-1;9029:1:18;9018:13;;8902:135::o

ipfs://56d71abb9e20dbab1f70162c4f5b60c1dd464c1913f55be9459b9b3bc4818dfd