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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/ISiloManagerFactory.sol";
import "./interfaces/ISiloFactory.sol";
import "./interfaces/ISiloSubFactory.sol";
import "./interfaces/ISilo.sol";

import "./gelato/AutomateTaskCreator.sol";

contract SiloManagerV2 is AutomateTaskCreator {
    bytes32 public taskId;

    address public owner;
    address public managerFactory;
    ISiloManagerFactory ManagerFactory;

    uint256 public topupThreshold;

    uint256 public topupAmount;

    mapping(address => bool) public whitelisted;

    address private lastSilo;
    uint256 private lastUpkeep;
    uint256 public fastGap;
    mapping(address => bool) public detected;
    bool public enableBurnCheck;

    uint256 public lastIndex;

    event SiloFastBurn(uint256 siloID);
    event SiloTopup(uint256 siloID, uint256 amount);
    event SiloUpdateThreshold(uint256 amount);
    event SiloUpdateTopupAmount(uint256 amount);

    modifier onlyWhitelisted() {
        require(
            whitelisted[msg.sender] || msg.sender == dedicatedMsgSender,
            "Only whitelisted"
        );
        _;
    }

    modifier onlyAdmin() {
        require(
            msg.sender == managerFactory ||
                msg.sender == owner ||
                tx.origin == owner,
            "Caller is not the admin"
        );
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the owner");
        _;
    }

    constructor(
        address _mangerFactory,
        address _owner,
        address _automate
    ) AutomateTaskCreator(_automate) {
        managerFactory = _mangerFactory;
        ManagerFactory = ISiloManagerFactory(managerFactory);
        owner = _owner;

        topupThreshold = ManagerFactory.topupThreshold();
        topupAmount = ManagerFactory.topupAmount();
    }

    function setEnableBurnCheck(bool _flag) external onlyOwner {
        enableBurnCheck = _flag;
    }

    function initDetected(address _silo) external onlyOwner {
        detected[_silo] = false;
    }

    function initFastBurn() external onlyOwner {
        lastSilo = address(0);
        lastUpkeep = 0;
    }

    function setFastGap(uint256 _gap) external onlyOwner {
        require(_gap > 0, "wrong duration");
        fastGap = _gap;
    }

    function createTask() external payable {
        require(taskId == bytes32(""), "Already started task");

        ModuleData memory moduleData = ModuleData({
            modules: new Module[](2),
            args: new bytes[](2)
        });

        moduleData.modules[0] = Module.RESOLVER;
        moduleData.modules[1] = Module.PROXY;

        moduleData.args[0] = _resolverModuleArg(
            address(this),
            abi.encodeCall(this.checkAuto, ())
        );

        moduleData.args[1] = _proxyModuleArg();

        bytes32 id = _createTask(
            address(this),
            abi.encode(this.performAuto.selector),
            moduleData,
            ETH
        );

        taskId = id;
    }

    function getBalance() public view returns (uint256 balance) {
        return address(this).balance;
    }

    function depositFunds() external payable {
        // _depositFunds(msg.value, ETH);
    }

    function withdrawFunds() external onlyAdmin {
        uint256 nativeBalance = address(this).balance;
        if (nativeBalance > 0) {
            (bool success, ) = payable(payable(owner)).call{
                value: nativeBalance
            }("");
            // require(success, "issue in native withdraw");
        }
    }

    function cancelAutomate() external onlyAdmin {
        _cancelTask(taskId);
    }

    function withdrawSelf() external onlyOwner {
        uint256 nativeBalance = address(this).balance;
        if (nativeBalance > 0) {
            (bool success, ) = payable(msg.sender).call{value: nativeBalance}(
                ""
            );
            require(success, "issue withdraw self");
        }
    }

    function adjustThreshold(uint256 _newThreshold) external onlyOwner {
        require(_newThreshold > ManagerFactory.minFunds(), "wrong threshold");
        topupThreshold = _newThreshold;
        emit SiloUpdateThreshold(_newThreshold);
    }

    function adjustTopupAmount(uint256 _amount) external onlyOwner {
        require(_amount > ManagerFactory.minFunds(), "wrong topup amount");
        topupAmount = _amount;
        emit SiloUpdateTopupAmount(_amount);
    }

    function adjustWhitelist(address caller, bool flag) external onlyOwner {
        whitelisted[caller] = flag;
    }

    function checkAuto()
        external
        view
        returns (bool canExec, bytes memory execPayload)
    {
        ISiloFactory SiloFactory = ISiloFactory(ManagerFactory.siloFactory());
        uint256 siloID;

        ISilo Silo;
        uint256 siloCount = SiloFactory.balanceOf(owner);
        if (lastIndex >= siloCount) {
            lastIndex == 0;
        }
        uint256 nativeBalance = address(this).balance;

        for (uint256 i = lastIndex; i < siloCount; ) {
            siloID = SiloFactory.tokenOfOwnerByIndex(owner, i);
            Silo = ISilo(SiloFactory.siloMap(siloID));
            if (
                Silo.getStatus() == Statuses.PAUSED ||
                !Silo.deposited() ||
                detected[address(Silo)]
            ) {
                unchecked {
                    i++;
                }
                continue; //skip this silo
            }

            uint256 balance = address(Silo).balance;

            if (balance < topupThreshold && nativeBalance > topupAmount) {
                canExec = true;

                execPayload = abi.encodeCall(this.performAuto, (address(Silo)));
                return (canExec, execPayload); //this will change the status of the silo to dormant
            }

            unchecked {
                i++;
            }
        }

        return (false, bytes("No silo to call"));
    }

    function performAuto(address actor) external onlyWhitelisted {
        if (actor != address(this)) {
            uint256 nativeBalance = address(this).balance;
            if (enableBurnCheck) {
                if (
                    lastSilo == actor && lastUpkeep + fastGap > block.timestamp
                ) {
                    detected[actor] = true;
                    emit SiloFastBurn(ISilo(actor).SILO_ID());
                } else {
                    if (nativeBalance > topupAmount) {
                        payable(actor).call{value: topupAmount}("");
                        // require(success, "issue in fill gas");

                        emit SiloTopup(ISilo(actor).SILO_ID(), topupAmount);
                    }
                }
                lastSilo = actor;
                lastUpkeep = block.timestamp;
            } else {
                if (nativeBalance > topupAmount) {
                    payable(actor).call{value: topupAmount}("");
                    // require(success, "issue in fill gas");
                    emit SiloTopup(ISilo(actor).SILO_ID(), topupAmount);
                }
            }
        }

        (uint256 fee, address feeToken) = _getFeeDetails();

        _transfer(fee, feeToken);
    }

    function ownerWithdraw(address _token, uint256 _amount) external {
        require(msg.sender == owner, "Only owner can withdraw ERC20s");
        SafeERC20.safeTransfer(IERC20(_token), msg.sender, _amount);
    }
}

// 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) (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
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

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

pragma solidity ^0.8.20;

import {IERC165} from "../../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 address zero.
     *
     * 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 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();
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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: UNLICENSED
pragma solidity ^0.8.14;

import "./Types.sol";

abstract contract AutomateModuleHelper {
    function _resolverModuleArg(
        address _resolverAddress,
        bytes memory _resolverData
    ) internal pure returns (bytes memory) {
        return abi.encode(_resolverAddress, _resolverData);
    }

    function _proxyModuleArg() internal pure returns (bytes memory) {
        return bytes("");
    }

    function _singleExecModuleArg() internal pure returns (bytes memory) {
        return bytes("");
    }

    function _web3FunctionModuleArg(
        string memory _web3FunctionHash,
        bytes memory _web3FunctionArgsHex
    ) internal pure returns (bytes memory) {
        return abi.encode(_web3FunctionHash, _web3FunctionArgsHex);
    }

    function _timeTriggerModuleArg(uint128 _start, uint128 _interval)
        internal
        pure
        returns (bytes memory)
    {
        bytes memory triggerConfig = abi.encode(_start, _interval);

        return abi.encode(TriggerType.TIME, triggerConfig);
    }

    function _cronTriggerModuleArg(string memory _expression)
        internal
        pure
        returns (bytes memory)
    {
        bytes memory triggerConfig = abi.encode(_expression);

        return abi.encode(TriggerType.CRON, triggerConfig);
    }

    function _eventTriggerModuleArg(
        address _address,
        bytes32[][] memory _topics,
        uint256 _blockConfirmations
    ) internal pure returns (bytes memory) {
        bytes memory triggerConfig = abi.encode(
            _address,
            _topics,
            _blockConfirmations
        );

        return abi.encode(TriggerType.EVENT, triggerConfig);
    }

    function _blockTriggerModuleArg() internal pure returns (bytes memory) {
        bytes memory triggerConfig = abi.encode(bytes(""));

        return abi.encode(TriggerType.BLOCK, triggerConfig);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./Types.sol";

/**
 * @dev Inherit this contract to allow your smart contract to
 * - Make synchronous fee payments.
 * - Have call restrictions for functions to be automated.
 */
// solhint-disable private-vars-leading-underscore
abstract contract AutomateReady {
    IAutomate public immutable automate;
    address public immutable dedicatedMsgSender;
    address private immutable feeCollector;
    address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

    /**
     * @dev
     * Only tasks created by _taskCreator defined in constructor can call
     * the functions with this modifier.
     */
    modifier onlyDedicatedMsgSender() {
        require(msg.sender == dedicatedMsgSender, "Only dedicated msg.sender");
        _;
    }

    /**
     * @dev
     * _taskCreator is the address which will create tasks for this contract.
     */
    constructor(address _automate, address _taskCreator) {
        automate = IAutomate(_automate);
        IGelato gelato = IGelato(IAutomate(_automate).gelato());

        feeCollector = gelato.feeCollector();

        address proxyModuleAddress = IAutomate(_automate).taskModuleAddresses(
            Module.PROXY
        );

        address opsProxyFactoryAddress = IProxyModule(proxyModuleAddress)
            .opsProxyFactory();

        (dedicatedMsgSender, ) = IOpsProxyFactory(opsProxyFactoryAddress)
            .getProxyOf(_taskCreator);
    }

    /**
     * @dev
     * Transfers fee to gelato for synchronous fee payments.
     *
     * _fee & _feeToken should be queried from IAutomate.getFeeDetails()
     */
    function _transfer(uint256 _fee, address _feeToken) internal {
        if (_feeToken == ETH) {
            (bool success, ) = feeCollector.call{value: _fee}("");
            require(success, "_transfer: ETH transfer failed");
        } else {
            SafeERC20.safeTransfer(IERC20(_feeToken), feeCollector, _fee);
        }
    }

    function _getFeeDetails()
        internal
        view
        returns (uint256 fee, address feeToken)
    {
        (fee, feeToken) = automate.getFeeDetails();
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./AutomateReady.sol";
import {AutomateModuleHelper} from "./AutomateModuleHelper.sol";

/**
 * @dev Inherit this contract to allow your smart contract
 * to be a task creator and create tasks.
 */
//solhint-disable const-name-snakecase
//solhint-disable no-empty-blocks
abstract contract AutomateTaskCreator is AutomateModuleHelper, AutomateReady {
    using SafeERC20 for IERC20;

    IGelato1Balance public constant gelato1Balance =
        IGelato1Balance(0x7506C12a824d73D9b08564d5Afc22c949434755e);

    constructor(address _automate) AutomateReady(_automate, address(this)) {}

    function _depositFunds1Balance(
        uint256 _amount,
        address _token,
        address _sponsor
    ) internal {
        if (_token == ETH) {
            ///@dev Only deposit ETH on goerli for now.
            require(block.chainid == 5, "Only deposit ETH on goerli");
            gelato1Balance.depositNative{value: _amount}(_sponsor);
        } else {
            ///@dev Only deposit USDC on polygon for now.
            require(
                block.chainid == 137 &&
                    _token ==
                    address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174),
                "Only deposit USDC on polygon"
            );
            IERC20(_token).approve(address(gelato1Balance), _amount);
            gelato1Balance.depositToken(_sponsor, _token, _amount);
        }
    }

    function _createTask(
        address _execAddress,
        bytes memory _execDataOrSelector,
        ModuleData memory _moduleData,
        address _feeToken
    ) internal returns (bytes32) {
        return
            automate.createTask(
                _execAddress,
                _execDataOrSelector,
                _moduleData,
                _feeToken
            );
    }

    function _cancelTask(bytes32 _taskId) internal {
        automate.cancelTask(_taskId);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.12;

enum Module {
    RESOLVER,
    DEPRECATED_TIME,
    PROXY,
    SINGLE_EXEC,
    WEB3_FUNCTION,
    TRIGGER
}

enum TriggerType {
    TIME,
    CRON,
    EVENT,
    BLOCK
}

struct ModuleData {
    Module[] modules;
    bytes[] args;
}

interface IAutomate {
    function createTask(
        address execAddress,
        bytes calldata execDataOrSelector,
        ModuleData calldata moduleData,
        address feeToken
    ) external returns (bytes32 taskId);

    function cancelTask(bytes32 taskId) external;

    function getFeeDetails() external view returns (uint256, address);

    function gelato() external view returns (address payable);

    function taskModuleAddresses(Module) external view returns (address);
}

interface IProxyModule {
    function opsProxyFactory() external view returns (address);
}

interface IOpsProxyFactory {
    function getProxyOf(address account) external view returns (address, bool);
}

interface IGelato1Balance {
    function depositNative(address _sponsor) external payable;

    function depositToken(
        address _sponsor,
        address _token,
        uint256 _amount
    ) external;
}

interface IGelato {
    function feeCollector() external view returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

struct PriceOracle {
    address oracle;
    uint256 actionPrice;
}

enum Statuses {
    PAUSED,
    DORMANT,
    MANAGED,
    UNWIND
}

interface ISilo {
    function deposit() external;

    function withdraw(uint256 _requestedOut) external;

    function maintain() external;

    function exitSilo(address caller) external;

    function adminCall(address target, bytes memory data) external;

    function setStrategy(
        address[5] memory input,
        bytes[] memory _configurationData,
        address[] memory _implementations
    ) external;

    function getConfig() external view returns (bytes memory config);

    function withdrawToken(address token, address recipient) external;

    function adjustSiloDelay(uint256 _newDelay) external;

    function SILO_ID() external view returns (uint256);

    function siloDelay() external view returns (uint256);

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

    function lastTimeMaintained() external view returns (uint256);

    function factory() external view returns (address);

    function setName(string memory name) external;

    function deposited() external view returns (bool);

    function isNew() external view returns (bool);

    function status() external view returns (Statuses);

    function setStrategyName(string memory _strategyName) external;

    function setStrategyCategory(uint256 _strategyCategory) external;

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

    function tokenMinimum(address token) external view returns (uint256);

    function strategyCategory() external view returns (uint256);

    // function main() external view returns (uint256);

    // function lastPid() external view returns (uint256);

    function adjustStrategy(
        uint256 _index,
        bytes memory _configurationData,
        address _implementation
    ) external;

    function viewStrategy()
        external
        view
        returns (address[] memory actions, bytes[] memory configData);

    function highRiskAction() external view returns (bool);

    function showActionStackValidity() external view returns (bool, bool);

    function getInputTokens() external view returns (address[5] memory);

    function getStatus() external view returns (Statuses);

    function pause() external;

    function unpause() external;

    function setActive() external;

    function possibleReinvestSilo() external view returns (bool possible);

    function getExtraSiloInfo()
        external
        view
        returns (
            uint256 strategyType,
            uint256 currentBalance,
            uint256 possibleWithdraw,
            uint256 availableBlock,
            uint256 pendingReward,
            uint256 lastPid
        );
}

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

import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";

interface ISiloFactory is IERC721Enumerable{
    function tokenMinimum(address _token) external view returns(uint _minimum);
    function balanceOf(address _owner) external view returns(uint);
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
    function managerFactory() external view returns(address);
    function siloMap(uint _id) external view returns(address);
    function tierManager() external view returns(address);
    function ownerOf(uint _id) external view returns(address);
    function siloToId(address silo) external view returns(uint);
    // function createSilo(address recipient) external returns(uint);
    function setActionStack(uint siloID, address[5] memory input, address[] memory _implementations, bytes[] memory _configurationData) external;
    // function withdraw(uint siloID) external;
    function getFeeInfo(address _action) external view returns(uint fee, address recipient);
    function strategyMaxGas() external view returns(uint);
    function strategyName(string memory _name) external view returns(uint);
    
    function getCatalogue(uint _type) external view returns(string[] memory);
    function getStrategyInputs(uint _id) external view returns(address[5] memory inputs);
    function getStrategyActions(uint _id) external view returns(address[] memory actions);
    function getStrategyConfigurationData(uint _id) external view returns(bytes[] memory configurationData);
    function useCustom(address _action) external view returns(bool);
    // function getFeeList(address _action) external view returns(uint[4] memory);
    function feeRecipient(address _action) external view returns(address);
    function defaultFeeList() external view returns(uint[4] memory);
    function defaultRecipient() external view returns(address);
    // function getTier(address _silo) external view returns(uint);

    function getFeeInfoNoTier(address _action) external view returns(uint[4] memory);
    function highRiskActions(address _action) external view returns(bool);
    function actionValid(address _action) external view returns(bool);
    function strategyValid(uint256 _strategyId) external view returns(bool);
    function skipActionValidTeamCheck(address _user) external view returns(bool);
    function skipActionValidLogicCheck(address _user) external view returns(bool);
    function isSilo(address _silo) external view returns(bool);

    function isSiloManager(address _silo,address _manager) external view returns(bool);

    function currentStrategyId() external view returns(uint);
    function minBalance() external view returns(uint);

    function mainActions(string memory strategyName) external view returns(uint);
    
    function subFactory() external view returns(address);
    function referral() external view returns(address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

enum AutoStatus {
    NOT,
    PENDING,
    APPROVED,
    MANUAL,
    LOW,
    NORMAL,
    HIGH
}

interface ISiloManager {
    function owner() external view returns (address);

    function taskId() external view returns (bytes32);

    function getBalance() external view returns (uint96);

    function depositFunds() external payable;

    function cancelAutomate() external;

    function withdrawFunds() external;

    function topupThreshold() external view returns (uint256);

    function topupAmount() external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {AutoStatus} from "./ISiloManager.sol";

struct ManagerInfo {
    address manager;
    bytes32 taskId;
    uint256 currentBalance;
    uint256 topupThreshold;
    uint256 minFunds;
}

interface ISiloManagerFactory {
    function checkManager(
        address _owner,
        address _manager
    ) external view returns (bool);

    function userToManager(address _user) external view returns (address);

    function isManager(address) external view returns (bool);

    function managerCount() external view returns (uint256);

    function siloFactory() external view returns (address);

    function getAutoStatus(address _user) external view returns (AutoStatus);

    function topupThreshold() external view returns (uint256);

    function minFunds() external view returns (uint256);

    function topupAmount() external view returns (uint256);

    function getAutomatorInfo(
        address _manager
    ) external view returns (ManagerInfo memory info);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ISiloSubFactory {
    function acceptTransfersFrom(address to, address from)
        external
        view
        returns (bool);

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

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

    function checkActionsLogicValid(
        address user,
        address[] memory _actions,
        bytes[] memory _configurationData
    ) external view returns (bool);

    function checkActionLogicValid(
        address user,
        address _implementation,
        bytes memory _configurationData
    ) external view returns(bool);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "viaIR": true,
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_mangerFactory","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_automate","type":"address"}],"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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"SiloFastBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SiloTopup","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SiloUpdateThreshold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SiloUpdateTopupAmount","type":"event"},{"inputs":[{"internalType":"uint256","name":"_newThreshold","type":"uint256"}],"name":"adjustThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"adjustTopupAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"adjustWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"automate","outputs":[{"internalType":"contract IAutomate","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelAutomate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"checkAuto","outputs":[{"internalType":"bool","name":"canExec","type":"bool"},{"internalType":"bytes","name":"execPayload","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createTask","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"dedicatedMsgSender","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositFunds","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"detected","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableBurnCheck","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fastGap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gelato1Balance","outputs":[{"internalType":"contract IGelato1Balance","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_silo","type":"address"}],"name":"initDetected","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initFastBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managerFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"ownerWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"actor","type":"address"}],"name":"performAuto","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_flag","type":"bool"}],"name":"setEnableBurnCheck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gap","type":"uint256"}],"name":"setFastGap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"taskId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"topupAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"topupThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawSelf","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d0cb3f6f341b92dfd4447fbd0db498434afc332e000000000000000000000000ee58cff202546728ce0e9af7b041e803c9bc4d80000000000000000000000000afd37d0558255aa687167560cd3aaeea75c2841e

-----Decoded View---------------
Arg [0] : _mangerFactory (address): 0xd0cB3f6f341b92dFD4447fBD0db498434AFc332e
Arg [1] : _owner (address): 0xEe58Cff202546728ce0e9AF7b041E803c9BC4d80
Arg [2] : _automate (address): 0xafd37d0558255aA687167560cd3AaeEa75c2841E

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000d0cb3f6f341b92dfd4447fbd0db498434afc332e
Arg [1] : 000000000000000000000000ee58cff202546728ce0e9af7b041e803c9bc4d80
Arg [2] : 000000000000000000000000afd37d0558255aa687167560cd3aaeea75c2841e