Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IPlatform} from "../interfaces/IPlatform.sol";
import {IMintedERC20} from "../interfaces/IMintedERC20.sol";
import {IBurnableERC20} from "../interfaces/IBurnableERC20.sol";

/// @title Token sale
/// @author Alien Deployer (https://github.com/a17)
contract Sale {
    using SafeERC20 for IERC20;

    uint public constant ALLOCATION_SALE = 4_000_000 * 10 ** 18;

    address public platform;
    address public token;
    address public receiptToken;
    address public spendToken;
    uint public price;
    uint public sold;
    uint64 public start;
    uint64 public end;
    uint64 public tge;
    mapping(address user => uint bought) public bought;

    constructor(address platform_, address spendToken_, uint price_, uint64 start_, uint64 end_, uint64 tge_) {
        platform = platform_;
        spendToken = spendToken_;
        price = price_;
        start = start_;
        end = end_;
        tge = tge_;
    }

    modifier onlyOperator() {
        _requireOperator();
        _;
    }

    function setupReceiptToken(address receiptToken_) external onlyOperator {
        require(receiptToken == address(0), "already");
        receiptToken = receiptToken_;
    }

    function setupToken(address token_) external onlyOperator {
        require(token == address(0), "already");
        require(IERC20(token_).balanceOf(address(this)) == ALLOCATION_SALE, "incorrect supply");
        token = token_;
    }

    function setupDates(uint64 start_, uint64 end_, uint64 tge_) external onlyOperator {
        require(block.timestamp < tge || token == address(0), "Cant change");
        start = start_;
        end = end_;
        tge = tge_;
    }

    function burnNotSold() external onlyOperator {
        address _token = token;
        require(_token != address(0) && block.timestamp >= tge, "Wait for TGE");
        uint toBurn = ALLOCATION_SALE - sold;
        require(toBurn != 0, "All sold");
        IBurnableERC20(_token).burn(toBurn);
    }

    function buy(uint amount) external {
        require(block.timestamp >= start, "Sale is not started yet");
        require(block.timestamp < end, "Sale ended");
        require(sold + amount <= ALLOCATION_SALE, "Too much");
        uint totalBought = bought[msg.sender];
        require(totalBought + amount <= ALLOCATION_SALE / 10, "Too much for user");
        uint toSpend = amount * price / 1e18;
        require(toSpend > 0, "Zero amount");
        sold += amount;
        IERC20(spendToken).safeTransferFrom(msg.sender, IPlatform(platform).multisig(), toSpend);
        IMintedERC20(receiptToken).mint(msg.sender, amount);
        bought[msg.sender] = totalBought + amount;
    }

    function claim() external {
        uint userBalance = IERC20(receiptToken).balanceOf(msg.sender);
        require(userBalance > 0, "You dont have not claimed tokens");
        address _token = token;
        require(_token != address(0) && block.timestamp >= tge, "Wait for TGE");
        IERC20(receiptToken).safeTransferFrom(msg.sender, address(this), userBalance);
        IBurnableERC20(receiptToken).burn(userBalance);
        IERC20(_token).safeTransfer(msg.sender, userBalance);
    }

    function _requireOperator() internal view {
        require(IPlatform(platform).isOperator(msg.sender), "denied");
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

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

/// @notice Interface of the main contract and entry point to the platform.
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IPlatform {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    error AlreadyAnnounced();
    error SameVersion();
    error NoNewVersion();
    error UpgradeTimerIsNotOver(uint TimerTimestamp);
    error IncorrectFee(uint minFee, uint maxFee);
    error NotEnoughAllowedBBToken();
    error TokenAlreadyExistsInSet(address token);
    error AggregatorNotExists(address dexAggRouter);

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    event PlatformVersion(string version);
    event UpgradeAnnounce(
        string oldVersion, string newVersion, address[] proxies, address[] newImplementations, uint timelock
    );
    event CancelUpgrade(string oldVersion, string newVersion);
    event ProxyUpgraded(
        address indexed proxy, address implementation, string oldContractVersion, string newContractVersion
    );
    event Addresses(
        address multisig_,
        address factory_,
        address priceReader_,
        address swapper_,
        address buildingPermitToken_,
        address vaultManager_,
        address strategyLogic_,
        address aprOracle_,
        address hardWorker,
        address rebalancer,
        address zap,
        address bridge
    );
    event OperatorAdded(address operator);
    event OperatorRemoved(address operator);
    event FeesChanged(uint fee, uint feeShareVaultManager, uint feeShareStrategyLogic, uint feeShareEcosystem);
    event MinInitialBoostChanged(uint minInitialBoostPerDay, uint minInitialBoostDuration);
    event NewAmmAdapter(string id, address proxy);
    event EcosystemRevenueReceiver(address receiver);
    event SetAllowedBBTokenVaults(address bbToken, uint vaultsToBuild, bool firstSet);
    event RemoveAllowedBBToken(address bbToken);
    event AddAllowedBoostRewardToken(address token);
    event RemoveAllowedBoostRewardToken(address token);
    event AddDefaultBoostRewardToken(address token);
    event RemoveDefaultBoostRewardToken(address token);
    event AddBoostTokens(address[] allowedBoostRewardToken, address[] defaultBoostRewardToken);
    event AllowedBBTokenVaultUsed(address bbToken, uint vaultToUse);
    event AddDexAggregator(address router);
    event RemoveDexAggregator(address router);
    event MinTvlForFreeHardWorkChanged(uint oldValue, uint newValue);
    event CustomVaultFee(address vault, uint platformFee);
    event Rebalancer(address rebalancer_);
    event Bridge(address bridge_);

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         DATA TYPES                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    struct PlatformUpgrade {
        string newVersion;
        address[] proxies;
        address[] newImplementations;
    }

    struct PlatformSettings {
        string networkName;
        bytes32 networkExtra;
        uint fee;
        uint feeShareVaultManager;
        uint feeShareStrategyLogic;
        uint feeShareEcosystem;
        uint minInitialBoostPerDay;
        uint minInitialBoostDuration;
    }

    struct AmmAdapter {
        string id;
        address proxy;
    }

    struct SetupAddresses {
        address factory;
        address priceReader;
        address swapper;
        address buildingPermitToken;
        address buildingPayPerVaultToken;
        address vaultManager;
        address strategyLogic;
        address aprOracle;
        address targetExchangeAsset;
        address hardWorker;
        address zap;
        address bridge;
        address rebalancer;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      VIEW FUNCTIONS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Platform version in CalVer scheme: YY.MM.MINOR-tag. Updates on core contract upgrades.
    function platformVersion() external view returns (string memory);

    /// @notice Time delay for proxy upgrades of core contracts and changing important platform settings by multisig
    //slither-disable-next-line naming-convention
    function TIME_LOCK() external view returns (uint);

    /// @notice DAO governance
    function governance() external view returns (address);

    /// @notice Core team multi signature wallet. Development and operations fund
    function multisig() external view returns (address);

    /// @notice This NFT allow user to build limited number of vaults per week
    function buildingPermitToken() external view returns (address);

    /// @notice This ERC20 token is used as payment token for vault building
    function buildingPayPerVaultToken() external view returns (address);

    /// @notice Receiver of ecosystem revenue
    function ecosystemRevenueReceiver() external view returns (address);

    /// @dev The best asset in a network for swaps between strategy assets and farms rewards assets
    ///      The target exchange asset is used for finding the best strategy's exchange asset.
    ///      Rhe fewer routes needed to swap to the target exchange asset, the better.
    function targetExchangeAsset() external view returns (address);

    /// @notice Platform factory assembling vaults. Stores settings, strategy logic, farms.
    /// Provides the opportunity to upgrade vaults and strategies.
    /// @return Address of Factory proxy
    function factory() external view returns (address);

    /// @notice The holders of these NFT receive a share of the vault revenue
    /// @return Address of VaultManager proxy
    function vaultManager() external view returns (address);

    /// @notice The holders of these tokens receive a share of the revenue received in all vaults using this strategy logic.
    function strategyLogic() external view returns (address);

    /// @notice Combining oracle and DeX spot prices
    /// @return Address of PriceReader proxy
    function priceReader() external view returns (address);

    /// @notice Providing underlying assets APRs on-chain
    /// @return Address of AprOracle proxy
    function aprOracle() external view returns (address);

    /// @notice On-chain price quoter and swapper
    /// @return Address of Swapper proxy
    function swapper() external view returns (address);

    /// @notice HardWork resolver and caller
    /// @return Address of HardWorker proxy
    function hardWorker() external view returns (address);

    /// @notice Rebalance resolver
    /// @return Address of Rebalancer proxy
    function rebalancer() external view returns (address);

    /// @notice ZAP feature
    /// @return Address of Zap proxy
    function zap() external view returns (address);

    /// @notice Stability Bridge
    /// @return Address of Bridge proxy
    function bridge() external view returns (address);

    /// @notice Name of current EVM network
    function networkName() external view returns (string memory);

    /// @notice Minimal initial boost rewards per day USD amount which needs to create rewarding vault
    function minInitialBoostPerDay() external view returns (uint);

    /// @notice Minimal boost rewards vesting duration for initial boost
    function minInitialBoostDuration() external view returns (uint);

    /// @notice This function provides the timestamp of the platform upgrade timelock.
    /// @dev This function is an external view function, meaning it doesn't modify the state.
    /// @return uint representing the timestamp of the platform upgrade timelock.
    function platformUpgradeTimelock() external view returns (uint);

    /// @dev Extra network data
    /// @return 0-2 bytes - color
    ///         3-5 bytes - background color
    ///         6-31 bytes - free
    function networkExtra() external view returns (bytes32);

    /// @notice Pending platform upgrade data
    function pendingPlatformUpgrade() external view returns (PlatformUpgrade memory);

    /// @notice Get platform revenue fee settings
    /// @return fee Revenue fee % (between MIN_FEE - MAX_FEE) with DENOMINATOR precision.
    /// @return feeShareVaultManager Revenue fee share % of VaultManager tokenId owner
    /// @return feeShareStrategyLogic Revenue fee share % of StrategyLogic tokenId owner
    /// @return feeShareEcosystem Revenue fee share % of ecosystemFeeReceiver
    function getFees()
        external
        view
        returns (uint fee, uint feeShareVaultManager, uint feeShareStrategyLogic, uint feeShareEcosystem);

    /// @notice Get custom vault platform fee
    /// @return fee revenue fee % with DENOMINATOR precision
    function getCustomVaultFee(address vault) external view returns (uint fee);

    /// @notice Platform settings
    function getPlatformSettings() external view returns (PlatformSettings memory);

    /// @notice AMM adapters of the platform
    function getAmmAdapters() external view returns (string[] memory id, address[] memory proxy);

    /// @notice Get AMM adapter data by hash
    /// @param ammAdapterIdHash Keccak256 hash of adapter ID string
    /// @return ID string and proxy address of AMM adapter
    function ammAdapter(bytes32 ammAdapterIdHash) external view returns (AmmAdapter memory);

    /// @notice Allowed buy-back tokens for rewarding vaults
    function allowedBBTokens() external view returns (address[] memory);

    /// @notice Vaults building limit for buy-back token.
    /// This limit decrements when a vault for BB-token is built.
    /// @param token Allowed buy-back token
    /// @return vaultsLimit Number of vaults that can be built for BB-token
    function allowedBBTokenVaults(address token) external view returns (uint vaultsLimit);

    /// @notice Vaults building limits for allowed buy-back tokens.
    /// @return bbToken Allowed buy-back tokens
    /// @return vaultsLimit Number of vaults that can be built for BB-tokens
    function allowedBBTokenVaults() external view returns (address[] memory bbToken, uint[] memory vaultsLimit);

    /// @notice Non-zero vaults building limits for allowed buy-back tokens.
    /// @return bbToken Allowed buy-back tokens
    /// @return vaultsLimit Number of vaults that can be built for BB-tokens
    function allowedBBTokenVaultsFiltered()
        external
        view
        returns (address[] memory bbToken, uint[] memory vaultsLimit);

    /// @notice Check address for existance in operators list
    /// @param operator Address
    /// @return True if this address is Stability Operator
    function isOperator(address operator) external view returns (bool);

    /// @notice Tokens that can be used for boost rewards of rewarding vaults
    /// @return Addresses of tokens
    function allowedBoostRewardTokens() external view returns (address[] memory);

    /// @notice Allowed boost reward tokens that used for unmanaged rewarding vaults creation
    /// @return Addresses of tokens
    function defaultBoostRewardTokens() external view returns (address[] memory);

    /// @notice Allowed boost reward tokens that used for unmanaged rewarding vaults creation
    /// @param addressToRemove This address will be removed from default boost reward tokens
    /// @return Addresses of tokens
    function defaultBoostRewardTokensFiltered(address addressToRemove) external view returns (address[] memory);

    /// @notice Allowed DeX aggregators
    /// @return Addresses of DeX aggregator rounters
    function dexAggregators() external view returns (address[] memory);

    /// @notice DeX aggregator router address is allowed to be used in the platform
    /// @param dexAggRouter Address of DeX aggreagator router
    /// @return Can be used
    function isAllowedDexAggregatorRouter(address dexAggRouter) external view returns (bool);

    /// @notice Show minimum TVL for compensate if vault has not enough ETH
    /// @return Minimum TVL for compensate.
    function minTvlForFreeHardWork() external view returns (uint);

    /// @notice Front-end platform viewer
    /// @return platformAddresses Platform core addresses
    ///        platformAddresses[0] factory
    ///        platformAddresses[1] vaultManager
    ///        platformAddresses[2] strategyLogic
    ///        platformAddresses[3] buildingPermitToken
    ///        platformAddresses[4] buildingPayPerVaultToken
    ///        platformAddresses[5] governance
    ///        platformAddresses[6] multisig
    ///        platformAddresses[7] zap
    ///        platformAddresses[8] bridge
    /// @return bcAssets Blue chip token addresses
    /// @return dexAggregators_ DeX aggregators allowed to be used entire the platform
    /// @return vaultType Vault type ID strings
    /// @return vaultExtra Vault color, background color and other extra data. Index of vault same as in previous array.
    /// @return vaultBulldingPrice Price of creating new vault in buildingPayPerVaultToken. Index of vault same as in previous array.
    /// @return strategyId Strategy logic ID strings
    /// @return isFarmingStrategy True if strategy is farming strategy. Index of strategy same as in previous array.
    /// @return strategyTokenURI StrategyLogic NFT tokenId metadata and on-chain image. Index of strategy same as in previous array.
    /// @return strategyExtra Strategy color, background color and other extra data. Index of strategy same as in previous array.
    function getData()
        external
        view
        returns (
            address[] memory platformAddresses,
            address[] memory bcAssets,
            address[] memory dexAggregators_,
            string[] memory vaultType,
            bytes32[] memory vaultExtra,
            uint[] memory vaultBulldingPrice,
            string[] memory strategyId,
            bool[] memory isFarmingStrategy,
            string[] memory strategyTokenURI,
            bytes32[] memory strategyExtra
        );

    /// @notice Front-end balances, prices and vault list viewer
    /// DEPRECATED: use IFrontend.getBalanceAssets and IFrontend.getBalanceVaults
    /// @param yourAccount Address of account to query balances
    /// @return token Tokens supported by the platform
    /// @return tokenPrice USD price of token. Index of token same as in previous array.
    /// @return tokenUserBalance User balance of token. Index of token same as in previous array.
    /// @return vault Deployed vaults
    /// @return vaultSharePrice Price 1.0 vault share. Index of vault same as in previous array.
    /// @return vaultUserBalance User balance of vault. Index of vault same as in previous array.
    /// @return nft Ecosystem NFTs
    ///         nft[0] BuildingPermitToken
    ///         nft[1] VaultManager
    ///         nft[2] StrategyLogic
    /// @return nftUserBalance User balance of NFT. Index of NFT same as in previous array.
    /// @return buildingPayPerVaultTokenBalance User balance of vault creation paying token
    function getBalance(address yourAccount)
        external
        view
        returns (
            address[] memory token,
            uint[] memory tokenPrice,
            uint[] memory tokenUserBalance,
            address[] memory vault,
            uint[] memory vaultSharePrice,
            uint[] memory vaultUserBalance,
            address[] memory nft,
            uint[] memory nftUserBalance,
            uint buildingPayPerVaultTokenBalance
        );

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      WRITE FUNCTIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Add platform operator.
    /// Only governance and multisig can add operator.
    /// @param operator Address of new operator
    function addOperator(address operator) external;

    /// @notice Remove platform operator.
    /// Only governance and multisig can remove operator.
    /// @param operator Address of operator to remove
    function removeOperator(address operator) external;

    /// @notice Announce upgrade of platform proxies implementations
    /// Only governance and multisig can announce platform upgrades.
    /// @param newVersion New platform version. Version must be changed when upgrading.
    /// @param proxies Addresses of core contract proxies
    /// @param newImplementations New implementation for proxy. Index of proxy same as in previous array.
    function announcePlatformUpgrade(
        string memory newVersion,
        address[] memory proxies,
        address[] memory newImplementations
    ) external;

    /// @notice Upgrade platform
    /// Only operator (multisig is operator too) can ececute pending platform upgrade
    function upgrade() external;

    /// @notice Cancel pending platform upgrade
    /// Only operator (multisig is operator too) can ececute pending platform upgrade
    function cancelUpgrade() external;

    /// @notice Register AMM adapter in platform
    /// @param id AMM adapter ID string from AmmAdapterIdLib
    /// @param proxy Address of AMM adapter proxy
    function addAmmAdapter(string memory id, address proxy) external;

    // todo Only governance and multisig can set allowed bb-token vaults building limit
    /// @notice Set new vaults building limit for buy-back token
    /// @param bbToken Address of allowed buy-back token
    /// @param vaultsToBuild Number of vaults that can be built for BB-token
    function setAllowedBBTokenVaults(address bbToken, uint vaultsToBuild) external;

    // todo Only governance and multisig can add allowed boost reward token
    /// @notice Add new allowed boost reward token
    /// @param token Address of token
    function addAllowedBoostRewardToken(address token) external;

    // todo Only governance and multisig can remove allowed boost reward token
    /// @notice Remove allowed boost reward token
    /// @param token Address of allowed boost reward token
    function removeAllowedBoostRewardToken(address token) external;

    // todo Only governance and multisig can add default boost reward token
    /// @notice Add default boost reward token
    /// @param token Address of default boost reward token
    function addDefaultBoostRewardToken(address token) external;

    // todo Only governance and multisig can remove default boost reward token
    /// @notice Remove default boost reward token
    /// @param token Address of allowed boost reward token
    function removeDefaultBoostRewardToken(address token) external;

    // todo Only governance and multisig can add allowed boost reward token
    // todo Only governance and multisig can add default boost reward token
    /// @notice Add new allowed boost reward token
    /// @notice Add default boost reward token
    /// @param allowedBoostRewardToken Address of allowed boost reward token
    /// @param defaultBoostRewardToken Address of default boost reward token
    function addBoostTokens(
        address[] memory allowedBoostRewardToken,
        address[] memory defaultBoostRewardToken
    ) external;

    /// @notice Decrease allowed BB-token vault building limit when vault is built
    /// Only Factory can do it.
    /// @param bbToken Address of allowed buy-back token
    function useAllowedBBTokenVault(address bbToken) external;

    /// @notice Allow DeX aggregator routers to be used in the platform
    /// @param dexAggRouter Addresses of DeX aggreagator routers
    function addDexAggregators(address[] memory dexAggRouter) external;

    /// @notice Remove allowed DeX aggregator router from the platform
    /// @param dexAggRouter Address of DeX aggreagator router
    function removeDexAggregator(address dexAggRouter) external;

    /// @notice Change initial boost rewards settings
    /// @param minInitialBoostPerDay_ Minimal initial boost rewards per day USD amount which needs to create rewarding vault
    /// @param minInitialBoostDuration_ Minimal boost rewards vesting duration for initial boost
    function setInitialBoost(uint minInitialBoostPerDay_, uint minInitialBoostDuration_) external;

    /// @notice Update new minimum TVL for compensate.
    /// @param value New minimum TVL for compensate.
    function setMinTvlForFreeHardWork(uint value) external;

    /// @notice Set custom platform fee for vault
    /// @param vault Vault address
    /// @param platformFee Custom platform fee
    function setCustomVaultFee(address vault, uint platformFee) external;

    /// @notice Setup Rebalancer.
    /// Only Goverannce or Multisig can do this when Rebalancer is not set.
    /// @param rebalancer_ Proxy address of Bridge
    function setupRebalancer(address rebalancer_) external;

    /// @notice Setup Bridge.
    /// Only Goverannce or Multisig can do this when Bridge is not set.
    /// @param bridge_ Proxy address of Bridge
    function setupBridge(address bridge_) external;
}

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

interface IMintedERC20 {
    /// @notice Mint token by owner
    /// @param to Address of receiver
    /// @param amount Amount of tokens to mint
    function mint(address to, uint amount) external;
}

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

interface IBurnableERC20 {
    /// @notice Destroys a `value` amount of tokens from the caller
    /// @param value Amount of tokens to burn
    function burn(uint value) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@solady/=lib/solady/src/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "solady/=lib/solady/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"platform_","type":"address"},{"internalType":"address","name":"spendToken_","type":"address"},{"internalType":"uint256","name":"price_","type":"uint256"},{"internalType":"uint64","name":"start_","type":"uint64"},{"internalType":"uint64","name":"end_","type":"uint64"},{"internalType":"uint64","name":"tge_","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"ALLOCATION_SALE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"bought","outputs":[{"internalType":"uint256","name":"bought","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnNotSold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"platform","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"receiptToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"start_","type":"uint64"},{"internalType":"uint64","name":"end_","type":"uint64"},{"internalType":"uint64","name":"tge_","type":"uint64"}],"name":"setupDates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiptToken_","type":"address"}],"name":"setupReceiptToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"setupToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"spendToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tge","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000004aca671a420eeb58ecafe83700686a2ad06b20d800000000000000000000000029219dd400f2bf60e5a23d13be72b486d4038894000000000000000000000000000000000000000000000000000000000001e8480000000000000000000000000000000000000000000000000000000067c794000000000000000000000000000000000000000000000000000000000067ce2b800000000000000000000000000000000000000000000000000000000067d0ce80

-----Decoded View---------------
Arg [0] : platform_ (address): 0x4Aca671A420eEB58ecafE83700686a2AD06b20D8
Arg [1] : spendToken_ (address): 0x29219dd400f2Bf60E5a23d13Be72B486D4038894
Arg [2] : price_ (uint256): 125000
Arg [3] : start_ (uint64): 1741132800
Arg [4] : end_ (uint64): 1741564800
Arg [5] : tge_ (uint64): 1741737600

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000004aca671a420eeb58ecafe83700686a2ad06b20d8
Arg [1] : 00000000000000000000000029219dd400f2bf60e5a23d13be72b486d4038894
Arg [2] : 000000000000000000000000000000000000000000000000000000000001e848
Arg [3] : 0000000000000000000000000000000000000000000000000000000067c79400
Arg [4] : 0000000000000000000000000000000000000000000000000000000067ce2b80
Arg [5] : 0000000000000000000000000000000000000000000000000000000067d0ce80