Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-10
*/

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/utils/Address.sol


// 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);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @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.
 */
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].
     */
    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);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;




/**
 * @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;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts/Vault.sol



pragma solidity ^0.8.11;




contract Vault {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address public auth;
    address public owner;
    address public tknContract;

    uint256 private unlockedBalance;
    uint256 private totalBalance;
    uint256 private startTime;

    uint256 private totalWithdraw;
    uint256 private initialTotal;

    uint256 public c_i = 9945; //decimal 4 (1 - 10000)
    uint256 public c_t = 730; // 1-1825
    uint256 public c_y0 = 0; //decimal 1 (0 - 1000)

    event Withdraw(address withdrawer, uint256 amount);

    /**
    @notice set inital parameters for this contract
    @param _c_i Concave (0 ~ 10000)
    @param _c_t Days (1 ~ 1825)
    @param _c_y0 Starting Point (0 ~ 1000) decimal
    */
    constructor(uint256 _c_i, uint256 _c_t, uint256 _c_y0) {
        auth = msg.sender;
        c_t = _c_t;
        c_i = _c_i;
        c_y0 = _c_y0;
    }

    /**
    @notice Set Token contract address
    @param _TknContract Token Contract Address
    */
    function setTkn(address _TknContract) public {
        require(tknContract == address(0), "tknContract is setted!");
        require(msg.sender == auth, "msg.sender is not Auth!");
        tknContract = _TknContract;

        startTime = block.timestamp;
    }

    /**
    @notice Set Owner
    @param _owner Owner who can withdraw tokens
    */
    function setOwner(address _owner) public {
        require(owner == address(0), "owner is setted!");
        require(msg.sender == auth, "msg.sender is not Auth!");
        owner = _owner;
    }

    /**
    @notice Get unlockedBalance and totalBalance for realtime
    */
    function getUnlocked_TotalBalance() public view returns (uint256, uint256){
        uint256 period = (block.timestamp - startTime) / 1 days;
        uint256 temp_unlock = IERC20(tknContract).balanceOf(address(this));

        if (initialTotal != 0)
            temp_unlock = initialTotal;

        if (period > c_t) period = c_t;

        uint256 b = 10 ** 18;
        uint256 a3_1 = b;
        uint256 a3_2;
        uint256 a3;
        
        for(uint16 k = 0; k < c_t; k ++){
            a3_1 *= c_i;
            a3_1 /= 10000;
        }
        a3_2 = b - a3_1;

        a3 = temp_unlock * a3_1 / a3_2;
        
        uint256 a1 = (1000 - c_y0);

        uint256 a2_1 = b;
        for (uint16 k = 0; k < period; k ++){
            a2_1 *= c_i;
            a2_1 /= 10000;
        }
        uint256 a2_2 = a2_1;
        a2_1 = b - a2_1;

        temp_unlock = a3 * a1 * a2_1 / a2_2 / 1000 + c_y0 * temp_unlock / 1000;

        if (period == c_t) temp_unlock = initialTotal;

        return (temp_unlock - totalWithdraw, IERC20(tknContract).balanceOf(address(this)));        
    }
    
    /**
    @notice withdraw token to destination address
    @param dest destination address
    @param amount amount of tokens
    */
    function withdraw(address dest, uint256 amount) public {
        if (initialTotal == 0) initialTotal = IERC20(tknContract).balanceOf(address(this));
        (unlockedBalance, totalBalance) = getUnlocked_TotalBalance();
        require(msg.sender == owner, "msg.sender is not Owner!");
        require(unlockedBalance > 0, "unlockedBalance is 0");
        require(amount <= unlockedBalance, "unlockedBalance is bigger");
        totalBalance -= amount;
        unlockedBalance -=amount;
        totalWithdraw += amount;
        IERC20(tknContract).transfer(dest, amount);
        emit Withdraw(dest, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_c_i","type":"uint256"},{"internalType":"uint256","name":"_c_t","type":"uint256"},{"internalType":"uint256","name":"_c_y0","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"withdrawer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"auth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"c_i","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"c_t","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"c_y0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUnlocked_TotalBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_TknContract","type":"address"}],"name":"setTkn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tknContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dest","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000026d900000000000000000000000000000000000000000000000000000000000002da0000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _c_i (uint256): 9945
Arg [1] : _c_t (uint256): 730
Arg [2] : _c_y0 (uint256): 0

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000026d9
Arg [1] : 00000000000000000000000000000000000000000000000000000000000002da
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000

26287:3581:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27680:198;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26742:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26701:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26403:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26430:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26645:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26377:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;27317:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;27966:1122;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;29241:624;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;27680:198;27757:1;27740:19;;:5;;;;;;;;;;;:19;;;27732:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;27813:4;;;;;;;;;;27799:18;;:10;:18;;;27791:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;27864:6;27856:5;;:14;;;;;;;;;;;;;;;;;;27680:198;:::o;26742:23::-;;;;:::o;26701:24::-;;;;:::o;26403:20::-;;;;;;;;;;;;;:::o;26430:26::-;;;;;;;;;;;;;:::o;26645:25::-;;;;:::o;26377:19::-;;;;;;;;;;;;:::o;27317:266::-;27404:1;27381:25;;:11;;;;;;;;;;;:25;;;27373:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;27466:4;;;;;;;;;;27452:18;;:10;:18;;;27444:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;27523:12;27509:11;;:26;;;;;;;;;;;;;;;;;;27560:15;27548:9;:27;;;;27317:266;:::o;27966:1122::-;28023:7;28032;28051:14;28100:6;28087:9;;28069:15;:27;;;;:::i;:::-;28068:38;;;;:::i;:::-;28051:55;;28117:19;28146:11;;;;;;;;;;;28139:29;;;28177:4;28139:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28117:66;;28216:1;28200:12;;:17;28196:62;;28246:12;;28232:26;;28196:62;28284:3;;28275:6;:12;28271:30;;;28298:3;;28289:12;;28271:30;28314:9;28326:8;28314:20;;28345:12;28360:1;28345:16;;28372:12;28395:10;28430:8;28426:98;28448:3;;28444:1;:7;;;28426:98;;;28481:3;;28473:11;;;;;:::i;:::-;;;28507:5;28499:13;;;;;:::i;:::-;;;28453:4;;;;;:::i;:::-;;;;28426:98;;;;28545:4;28541:1;:8;;;;:::i;:::-;28534:15;;28588:4;28581;28567:11;:18;;;;:::i;:::-;:25;;;;:::i;:::-;28562:30;;28613:10;28634:4;;28627;:11;;;;:::i;:::-;28613:26;;28652:12;28667:1;28652:16;;28684:8;28679:102;28702:6;28698:1;:10;;;28679:102;;;28738:3;;28730:11;;;;;:::i;:::-;;;28764:5;28756:13;;;;;:::i;:::-;;;28710:4;;;;;:::i;:::-;;;;28679:102;;;;28791:12;28806:4;28791:19;;28832:4;28828:1;:8;;;;:::i;:::-;28821:15;;28915:4;28901:11;28894:4;;:18;;;;:::i;:::-;:25;;;;:::i;:::-;28887:4;28880;28873;28868:2;28863;:7;;;;:::i;:::-;:14;;;;:::i;:::-;:21;;;;:::i;:::-;:28;;;;:::i;:::-;:56;;;;:::i;:::-;28849:70;;28946:3;;28936:6;:13;28932:45;;28965:12;;28951:26;;28932:45;29012:13;;28998:11;:27;;;;:::i;:::-;29034:11;;;;;;;;;;;29027:29;;;29065:4;29027:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28990:82;;;;;;;;;;;;;27966:1122;;:::o;29241:624::-;29327:1;29311:12;;:17;29307:82;;29352:11;;;;;;;;;;;29345:29;;;29383:4;29345:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;29330:12;:59;;;;29307:82;29434:26;:24;:26::i;:::-;29401:15;;29418:12;;29400:60;;;;;;;;;;;;29493:5;;;;;;;;;;;29479:19;;:10;:19;;;29471:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;29564:1;29546:15;;:19;29538:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;29619:15;;29609:6;:25;;29601:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;29691:6;29675:12;;:22;;;;;;;:::i;:::-;;;;;;;;29726:6;29708:15;;:24;;;;;;;:::i;:::-;;;;;;;;29760:6;29743:13;;:23;;;;;;;:::i;:::-;;;;;;;;29784:11;;;;;;;;;;;29777:28;;;29806:4;29812:6;29777:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;29835:22;29844:4;29850:6;29835:22;;;;;;;:::i;:::-;;;;;;;;29241:624;;:::o;88:117:1:-;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:118::-;1698:24;1716:5;1698:24;:::i;:::-;1693:3;1686:37;1611:118;;:::o;1735:222::-;1828:4;1866:2;1855:9;1851:18;1843:26;;1879:71;1947:1;1936:9;1932:17;1923:6;1879:71;:::i;:::-;1735:222;;;;:::o;1963:332::-;2084:4;2122:2;2111:9;2107:18;2099:26;;2135:71;2203:1;2192:9;2188:17;2179:6;2135:71;:::i;:::-;2216:72;2284:2;2273:9;2269:18;2260:6;2216:72;:::i;:::-;1963:332;;;;;:::o;2301:122::-;2374:24;2392:5;2374:24;:::i;:::-;2367:5;2364:35;2354:63;;2413:1;2410;2403:12;2354:63;2301:122;:::o;2429:139::-;2475:5;2513:6;2500:20;2491:29;;2529:33;2556:5;2529:33;:::i;:::-;2429:139;;;;:::o;2574:474::-;2642:6;2650;2699:2;2687:9;2678:7;2674:23;2670:32;2667:119;;;2705:79;;:::i;:::-;2667:119;2825:1;2850:53;2895:7;2886:6;2875:9;2871:22;2850:53;:::i;:::-;2840:63;;2796:117;2952:2;2978:53;3023:7;3014:6;3003:9;2999:22;2978:53;:::i;:::-;2968:63;;2923:118;2574:474;;;;;:::o;3054:169::-;3138:11;3172:6;3167:3;3160:19;3212:4;3207:3;3203:14;3188:29;;3054:169;;;;:::o;3229:166::-;3369:18;3365:1;3357:6;3353:14;3346:42;3229:166;:::o;3401:366::-;3543:3;3564:67;3628:2;3623:3;3564:67;:::i;:::-;3557:74;;3640:93;3729:3;3640:93;:::i;:::-;3758:2;3753:3;3749:12;3742:19;;3401:366;;;:::o;3773:419::-;3939:4;3977:2;3966:9;3962:18;3954:26;;4026:9;4020:4;4016:20;4012:1;4001:9;3997:17;3990:47;4054:131;4180:4;4054:131;:::i;:::-;4046:139;;3773:419;;;:::o;4198:173::-;4338:25;4334:1;4326:6;4322:14;4315:49;4198:173;:::o;4377:366::-;4519:3;4540:67;4604:2;4599:3;4540:67;:::i;:::-;4533:74;;4616:93;4705:3;4616:93;:::i;:::-;4734:2;4729:3;4725:12;4718:19;;4377:366;;;:::o;4749:419::-;4915:4;4953:2;4942:9;4938:18;4930:26;;5002:9;4996:4;4992:20;4988:1;4977:9;4973:17;4966:47;5030:131;5156:4;5030:131;:::i;:::-;5022:139;;4749:419;;;:::o;5174:172::-;5314:24;5310:1;5302:6;5298:14;5291:48;5174:172;:::o;5352:366::-;5494:3;5515:67;5579:2;5574:3;5515:67;:::i;:::-;5508:74;;5591:93;5680:3;5591:93;:::i;:::-;5709:2;5704:3;5700:12;5693:19;;5352:366;;;:::o;5724:419::-;5890:4;5928:2;5917:9;5913:18;5905:26;;5977:9;5971:4;5967:20;5963:1;5952:9;5948:17;5941:47;6005:131;6131:4;6005:131;:::i;:::-;5997:139;;5724:419;;;:::o;6149:180::-;6197:77;6194:1;6187:88;6294:4;6291:1;6284:15;6318:4;6315:1;6308:15;6335:194;6375:4;6395:20;6413:1;6395:20;:::i;:::-;6390:25;;6429:20;6447:1;6429:20;:::i;:::-;6424:25;;6473:1;6470;6466:9;6458:17;;6497:1;6491:4;6488:11;6485:37;;;6502:18;;:::i;:::-;6485:37;6335:194;;;;:::o;6535:180::-;6583:77;6580:1;6573:88;6680:4;6677:1;6670:15;6704:4;6701:1;6694:15;6721:185;6761:1;6778:20;6796:1;6778:20;:::i;:::-;6773:25;;6812:20;6830:1;6812:20;:::i;:::-;6807:25;;6851:1;6841:35;;6856:18;;:::i;:::-;6841:35;6898:1;6895;6891:9;6886:14;;6721:185;;;;:::o;6912:143::-;6969:5;7000:6;6994:13;6985:22;;7016:33;7043:5;7016:33;:::i;:::-;6912:143;;;;:::o;7061:351::-;7131:6;7180:2;7168:9;7159:7;7155:23;7151:32;7148:119;;;7186:79;;:::i;:::-;7148:119;7306:1;7331:64;7387:7;7378:6;7367:9;7363:22;7331:64;:::i;:::-;7321:74;;7277:128;7061:351;;;;:::o;7418:410::-;7458:7;7481:20;7499:1;7481:20;:::i;:::-;7476:25;;7515:20;7533:1;7515:20;:::i;:::-;7510:25;;7570:1;7567;7563:9;7592:30;7610:11;7592:30;:::i;:::-;7581:41;;7771:1;7762:7;7758:15;7755:1;7752:22;7732:1;7725:9;7705:83;7682:139;;7801:18;;:::i;:::-;7682:139;7466:362;7418:410;;;;:::o;7834:89::-;7870:7;7910:6;7903:5;7899:18;7888:29;;7834:89;;;:::o;7929:171::-;7967:3;7990:23;8007:5;7990:23;:::i;:::-;7981:32;;8035:6;8028:5;8025:17;8022:43;;8045:18;;:::i;:::-;8022:43;8092:1;8085:5;8081:13;8074:20;;7929:171;;;:::o;8106:191::-;8146:3;8165:20;8183:1;8165:20;:::i;:::-;8160:25;;8199:20;8217:1;8199:20;:::i;:::-;8194:25;;8242:1;8239;8235:9;8228:16;;8263:3;8260:1;8257:10;8254:36;;;8270:18;;:::i;:::-;8254:36;8106:191;;;;:::o;8303:174::-;8443:26;8439:1;8431:6;8427:14;8420:50;8303:174;:::o;8483:366::-;8625:3;8646:67;8710:2;8705:3;8646:67;:::i;:::-;8639:74;;8722:93;8811:3;8722:93;:::i;:::-;8840:2;8835:3;8831:12;8824:19;;8483:366;;;:::o;8855:419::-;9021:4;9059:2;9048:9;9044:18;9036:26;;9108:9;9102:4;9098:20;9094:1;9083:9;9079:17;9072:47;9136:131;9262:4;9136:131;:::i;:::-;9128:139;;8855:419;;;:::o;9280:170::-;9420:22;9416:1;9408:6;9404:14;9397:46;9280:170;:::o;9456:366::-;9598:3;9619:67;9683:2;9678:3;9619:67;:::i;:::-;9612:74;;9695:93;9784:3;9695:93;:::i;:::-;9813:2;9808:3;9804:12;9797:19;;9456:366;;;:::o;9828:419::-;9994:4;10032:2;10021:9;10017:18;10009:26;;10081:9;10075:4;10071:20;10067:1;10056:9;10052:17;10045:47;10109:131;10235:4;10109:131;:::i;:::-;10101:139;;9828:419;;;:::o;10253:175::-;10393:27;10389:1;10381:6;10377:14;10370:51;10253:175;:::o;10434:366::-;10576:3;10597:67;10661:2;10656:3;10597:67;:::i;:::-;10590:74;;10673:93;10762:3;10673:93;:::i;:::-;10791:2;10786:3;10782:12;10775:19;;10434:366;;;:::o;10806:419::-;10972:4;11010:2;10999:9;10995:18;10987:26;;11059:9;11053:4;11049:20;11045:1;11034:9;11030:17;11023:47;11087:131;11213:4;11087:131;:::i;:::-;11079:139;;10806:419;;;:::o;11231:332::-;11352:4;11390:2;11379:9;11375:18;11367:26;;11403:71;11471:1;11460:9;11456:17;11447:6;11403:71;:::i;:::-;11484:72;11552:2;11541:9;11537:18;11528:6;11484:72;:::i;:::-;11231:332;;;;;:::o;11569:90::-;11603:7;11646:5;11639:13;11632:21;11621:32;;11569:90;;;:::o;11665:116::-;11735:21;11750:5;11735:21;:::i;:::-;11728:5;11725:32;11715:60;;11771:1;11768;11761:12;11715:60;11665:116;:::o;11787:137::-;11841:5;11872:6;11866:13;11857:22;;11888:30;11912:5;11888:30;:::i;:::-;11787:137;;;;:::o;11930:345::-;11997:6;12046:2;12034:9;12025:7;12021:23;12017:32;12014:119;;;12052:79;;:::i;:::-;12014:119;12172:1;12197:61;12250:7;12241:6;12230:9;12226:22;12197:61;:::i;:::-;12187:71;;12143:125;11930:345;;;;:::o

ipfs://c095ae01c5f78b6107618325134addf4e52c43f95c2b4e40ace5ad9719446e65