Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract Deposit is Context, Ownable{
    using SafeERC20 for IERC20;
    IERC20[] public tokens;

    address[] private beneficiaries;
    mapping(uint256 => uint256) public totalDeposited;
    uint256 public allOrderId;

    struct Order {
        address owner;
        address beneficiaryAddr;
        uint256 orderId;
        uint256 orderDate; //timestamp
        uint256 amount;
        uint256 tokenType;
        string account;
    }

    mapping(uint256 => Order) public allOrders;

    event DepositToken(
        address owner,
        uint256 orderId,
        uint256 amount,
        uint256 tokenType,
        string account
    );

    constructor() Ownable(msg.sender){
    }

    function addTokensType(address _token) public onlyOwner {
        require(_token != address(0), "Invalid token");
        tokens.push(IERC20(_token));
    }

    function getTokensType(
        uint256 index
    ) public view returns (IERC20) {
        return tokens[index];
    }

    function addBeneficiary(address _beneficiary) public onlyOwner {
        require(_beneficiary != address(0), "Invalid Beneficiary");
        beneficiaries.push(_beneficiary);
    }

    function getBeneficiaries()
        public
        view
        onlyOwner
        returns (address[] memory)
    {
        return beneficiaries;
    }

    //==============================
    //            MAIN
    //==============================
    function deposit(
        uint256 _amt,
        string memory _account,
        uint256 _tokenType
    ) public {
        require(_amt > 0, "Amount cannot be empty");
        require(beneficiaries.length > 0, "Beneficiary empty");
        require(_tokenType < tokens.length, "Token type not found");
        allOrderId++; //starts with 1

        uint256 beneficiaryIndex = (allOrderId - 1) % beneficiaries.length;
        address beneficiaryAddr = beneficiaries[beneficiaryIndex];

        //add new order
        Order memory newOrder;
        newOrder.owner = msg.sender;
        newOrder.beneficiaryAddr = beneficiaryAddr;
        newOrder.orderDate = block.timestamp;
        newOrder.amount = _amt;
        newOrder.orderId = allOrderId;
        newOrder.tokenType = _tokenType;
        newOrder.account = _account;
        allOrders[allOrderId] = newOrder; //order struct new order

        totalDeposited[_tokenType] += _amt;

        tokens[_tokenType].safeTransferFrom(msg.sender, beneficiaryAddr, _amt);

        emit DepositToken(msg.sender, allOrderId, _amt, _tokenType, _account);
    }
}

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

pragma solidity ^0.8.7;

import {Context} from "../utils/Context.sol";

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

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

pragma solidity ^0.8.7;

/**
 * @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/extensions/IERC20Permit.sol)

pragma solidity ^0.8.7;

/**
 * @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/utils/SafeERC20.sol)

pragma solidity ^0.8.7;

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) (utils/Address.sol)

pragma solidity ^0.8.7;

/**
 * @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/Context.sol)

pragma solidity ^0.8.7;

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenType","type":"uint256"},{"indexed":false,"internalType":"string","name":"account","type":"string"}],"name":"DepositToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"addBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"addTokensType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allOrderId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allOrders","outputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"beneficiaryAddr","type":"address"},{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"uint256","name":"orderDate","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"string","name":"account","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amt","type":"uint256"},{"internalType":"string","name":"_account","type":"string"},{"internalType":"uint256","name":"_tokenType","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getBeneficiaries","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getTokensType","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokens","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"totalDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

234:2613:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1129:122;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;377:32:7;;;359:51;;347:2;332:18;1129:122:6;;;;;;;;310:22;;;;;;:::i;:::-;;:::i;1259:183::-;;;;;;:::i;:::-;;:::i;:::-;;2292:101:0;;;:::i;435:25:6:-;;;;;;;;;858::7;;;846:2;831:18;435:25:6;712:177:7;962:159:6;;;;;;:::i;:::-;;:::i;1715:1129::-;;;;;;:::i;:::-;;:::i;1637:85:0:-;1683:7;1709:6;-1:-1:-1;;;;;1709:6:0;1637:85;;1450:157:6;;;:::i;:::-;;;;;;;:::i;379:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;700:42;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;:::i;2542:215:0:-;;;;;;:::i;:::-;;:::i;1129:122:6:-;1204:6;1230;1237:5;1230:13;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;1230:13:6;;1129:122;-1:-1:-1;;1129:122:6:o;310:22::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;310:22:6;;-1:-1:-1;310:22:6;:::o;1259:183::-;1530:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1341:26:6;::::1;1333:58;;;::::0;-1:-1:-1;;;1333:58:6;;4532:2:7;1333:58:6::1;::::0;::::1;4514:21:7::0;4571:2;4551:18;;;4544:30;-1:-1:-1;;;4590:18:7;;;4583:49;4649:18;;1333:58:6::1;;;;;;;;;1402:13;:32:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;1402:32:6;;;;;::::1;::::0;;-1:-1:-1;;;;;;1402:32:6::1;-1:-1:-1::0;;;;;1402:32:6;;;::::1;::::0;;;::::1;::::0;;1259:183::o;2292:101:0:-;1530:13;:11;:13::i;:::-;2356:30:::1;2383:1;2356:18;:30::i;:::-;2292:101::o:0;962:159:6:-;1530:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1037:20:6;::::1;1029:46;;;::::0;-1:-1:-1;;;1029:46:6;;4880:2:7;1029:46:6::1;::::0;::::1;4862:21:7::0;4919:2;4899:18;;;4892:30;-1:-1:-1;;;4938:18:7;;;4931:43;4991:18;;1029:46:6::1;4678:337:7::0;1029:46:6::1;1086:6;:27:::0;;;;::::1;::::0;;-1:-1:-1;1086:27:6;;;;;::::1;::::0;;-1:-1:-1;;;;;;1086:27:6::1;-1:-1:-1::0;;;;;1086:27:6;;;::::1;::::0;;;::::1;::::0;;962:159::o;1715:1129::-;1857:1;1850:4;:8;1842:43;;;;-1:-1:-1;;;1842:43:6;;5222:2:7;1842:43:6;;;5204:21:7;5261:2;5241:18;;;5234:30;-1:-1:-1;;;5280:18:7;;;5273:52;5342:18;;1842:43:6;5020:346:7;1842:43:6;1904:13;:20;1896:54;;;;-1:-1:-1;;;1896:54:6;;5573:2:7;1896:54:6;;;5555:21:7;5612:2;5592:18;;;5585:30;-1:-1:-1;;;5631:18:7;;;5624:47;5688:18;;1896:54:6;5371:341:7;1896:54:6;1982:6;:13;1969:26;;1961:59;;;;-1:-1:-1;;;1961:59:6;;5919:2:7;1961:59:6;;;5901:21:7;5958:2;5938:18;;;5931:30;-1:-1:-1;;;5977:18:7;;;5970:50;6037:18;;1961:59:6;5717:344:7;1961:59:6;2031:10;:12;;;:10;:12;;;:::i;:::-;;;;-1:-1:-1;;2118:13:6;:20;2100:10;;2072:24;;2118:20;2100:14;;2113:1;;2100:14;:::i;:::-;2099:39;;;;:::i;:::-;2072:66;;2149:23;2175:13;2189:16;2175:31;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2175:31:6;2149:57;;2244:21;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2244:21:6;2293:10;2276:27;;-1:-1:-1;;;;;2314:42:6;;;:24;;;;:42;;;2388:15;2367:18;;;:36;;;2414:15;;;:22;;;2466:10;;;2447:16;;;;:29;;;2487:18;;;:31;;;2529:16;;;:27;;;2276:14;2567:21;;;:9;:21;;;;;;;:32;;;;;;;-1:-1:-1;;;;;;2567:32:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2276:8;;2567:32;;;;;;;;;;:::i;:::-;-1:-1:-1;;;2637:26:6;;;;:14;:26;;;;;:34;;2667:4;;2637:26;:34;;2667:4;;2637:34;:::i;:::-;;;;;;;;2684:70;2720:10;2732:15;2749:4;2684:6;2691:10;2684:18;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;2684:18:6;;:70;;:35;:70::i;:::-;2772:64;2785:10;2797;;2809:4;2815:10;2827:8;2772:64;;;;;;;;;;:::i;:::-;;;;;;;;1831:1013;;;1715:1129;;;:::o;1450:157::-;1545:16;1530:13:0;:11;:13::i;:::-;1586::6::1;1579:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;1579:20:6::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;;;1450:157:::0;:::o;700:42::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;700:42:6;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2542:215:0:-;1530:13;:11;:13::i;:::-;-1:-1:-1;;;;;2626:22:0;::::1;2622:91;;2671:31;::::0;-1:-1:-1;;;2671:31:0;;2699:1:::1;2671:31;::::0;::::1;359:51:7::0;332:18;;2671:31:0::1;199:217:7::0;2622:91:0::1;2722:28;2741:8;2722:18;:28::i;:::-;2542:215:::0;:::o;1795:162::-;1683:7;1709:6;-1:-1:-1;;;;;1709:6:0;734:10:5;1854:23:0;1850:101;;1900:40;;-1:-1:-1;;;1900:40:0;;734:10:5;1900:40:0;;;359:51:7;332:18;;1900:40:0;199:217:7;2911:187:0;2984:16;3003:6;;-1:-1:-1;;;;;3019:17:0;;;-1:-1:-1;;;;;;3019:17:0;;;;;;3051:40;;3003:6;;;;;;;3051:40;;2984:16;3051:40;2974:124;2911:187;:::o;1701:188:3:-;1828:53;;;-1:-1:-1;;;;;7996:15:7;;;1828:53:3;;;7978:34:7;8048:15;;8028:18;;;8021:43;8080:18;;;;8073:34;;;1828:53:3;;;;;;;;;;7913:18:7;;;;1828:53:3;;;;;;;;-1:-1:-1;;;;;1828:53:3;-1:-1:-1;;;1828:53:3;;;1801:81;;1821:5;;1801:19;:81::i;:::-;1701:188;;;;:::o;4058:629::-;4477:23;4503:33;-1:-1:-1;;;;;4503:27:3;;4531:4;4503:27;:33::i;:::-;4477:59;;4550:10;:17;4571:1;4550:22;;:57;;;;;4588:10;4577:30;;;;;;;;;;;;:::i;:::-;4576:31;4550:57;4546:135;;;4630:40;;-1:-1:-1;;;4630:40:3;;-1:-1:-1;;;;;377:32:7;;4630:40:3;;;359:51:7;332:18;;4630:40:3;199:217:7;4546:135:3;4128:559;4058:629;;:::o;2704:151:4:-;2779:12;2810:38;2832:6;2840:4;2846:1;2810:21;:38::i;:::-;2803:45;2704:151;-1:-1:-1;;;2704:151:4:o;3179:392::-;3278:12;3330:5;3306:21;:29;3302:108;;;3358:41;;-1:-1:-1;;;3358:41:4;;3393:4;3358:41;;;359:51:7;332:18;;3358:41:4;199:217:7;3302:108:4;3420:12;3434:23;3461:6;-1:-1:-1;;;;;3461:11:4;3480:5;3487:4;3461:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3419:73;;;;3509:55;3536:6;3544:7;3553:10;3509:26;:55::i;:::-;3502:62;3179:392;-1:-1:-1;;;;;;3179:392:4:o;4624:582::-;4768:12;4797:7;4792:408;;4820:19;4828:10;4820:7;:19::i;:::-;4792:408;;;5044:17;;:22;:49;;;;-1:-1:-1;;;;;;5070:18:4;;;:23;5044:49;5040:119;;;5120:24;;-1:-1:-1;;;5120:24:4;;-1:-1:-1;;;;;377:32:7;;5120:24:4;;;359:51:7;332:18;;5120:24:4;199:217:7;5040:119:4;-1:-1:-1;5179:10:4;5172:17;;5742:516;5873:17;;:21;5869:383;;6101:10;6095:17;6157:15;6144:10;6140:2;6136:19;6129:44;5869:383;6224:17;;-1:-1:-1;;;6224:17:4;;;;;;;;;;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:180:7;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:7;;14:180;-1:-1:-1;14:180:7:o;421:286::-;480:6;533:2;521:9;512:7;508:23;504:32;501:52;;;549:1;546;539:12;501:52;575:23;;-1:-1:-1;;;;;627:31:7;;617:42;;607:70;;673:1;670;663:12;894:127;955:10;950:3;946:20;943:1;936:31;986:4;983:1;976:15;1010:4;1007:1;1000:15;1026:1058;1113:6;1121;1129;1182:2;1170:9;1161:7;1157:23;1153:32;1150:52;;;1198:1;1195;1188:12;1150:52;1234:9;1221:23;1211:33;;1295:2;1284:9;1280:18;1267:32;1318:18;1359:2;1351:6;1348:14;1345:34;;;1375:1;1372;1365:12;1345:34;1413:6;1402:9;1398:22;1388:32;;1458:7;1451:4;1447:2;1443:13;1439:27;1429:55;;1480:1;1477;1470:12;1429:55;1516:2;1503:16;1538:2;1534;1531:10;1528:36;;;1544:18;;:::i;:::-;1619:2;1613:9;1587:2;1673:13;;-1:-1:-1;;1669:22:7;;;1693:2;1665:31;1661:40;1649:53;;;1717:18;;;1737:22;;;1714:46;1711:72;;;1763:18;;:::i;:::-;1803:10;1799:2;1792:22;1838:2;1830:6;1823:18;1878:7;1873:2;1868;1864;1860:11;1856:20;1853:33;1850:53;;;1899:1;1896;1889:12;1850:53;1955:2;1950;1946;1942:11;1937:2;1929:6;1925:15;1912:46;2000:1;1995:2;1990;1982:6;1978:15;1974:24;1967:35;2021:6;2011:16;;;;;;;2074:2;2063:9;2059:18;2046:32;2036:42;;1026:1058;;;;;:::o;2297:658::-;2468:2;2520:21;;;2590:13;;2493:18;;;2612:22;;;2439:4;;2468:2;2691:15;;;;2665:2;2650:18;;;2439:4;2734:195;2748:6;2745:1;2742:13;2734:195;;;2813:13;;-1:-1:-1;;;;;2809:39:7;2797:52;;2904:15;;;;2869:12;;;;2845:1;2763:9;2734:195;;;-1:-1:-1;2946:3:7;;2297:658;-1:-1:-1;;;;;;2297:658:7:o;2960:258::-;3032:1;3042:113;3056:6;3053:1;3050:13;3042:113;;;3132:11;;;3126:18;3113:11;;;3106:39;3078:2;3071:10;3042:113;;;3173:6;3170:1;3167:13;3164:48;;;-1:-1:-1;;3208:1:7;3190:16;;3183:27;2960:258::o;3223:::-;3265:3;3303:5;3297:12;3330:6;3325:3;3318:19;3346:63;3402:6;3395:4;3390:3;3386:14;3379:4;3372:5;3368:16;3346:63;:::i;:::-;3463:2;3442:15;-1:-1:-1;;3438:29:7;3429:39;;;;3470:4;3425:50;;3223:258;-1:-1:-1;;3223:258:7:o;3486:707::-;3766:4;3812:1;3808;3803:3;3799:11;3795:19;3853:2;3845:6;3841:15;3830:9;3823:34;3905:2;3897:6;3893:15;3888:2;3877:9;3873:18;3866:43;;3945:6;3940:2;3929:9;3925:18;3918:34;3988:6;3983:2;3972:9;3968:18;3961:34;4032:6;4026:3;4015:9;4011:19;4004:35;4076:6;4070:3;4059:9;4055:19;4048:35;4120:3;4114;4103:9;4099:19;4092:32;4141:46;4182:3;4171:9;4167:19;4159:6;4141:46;:::i;:::-;4133:54;3486:707;-1:-1:-1;;;;;;;;;3486:707:7:o;4198:127::-;4259:10;4254:3;4250:20;4247:1;4240:31;4290:4;4287:1;4280:15;4314:4;4311:1;4304:15;6066:127;6127:10;6122:3;6118:20;6115:1;6108:31;6158:4;6155:1;6148:15;6182:4;6179:1;6172:15;6198:135;6237:3;-1:-1:-1;;6258:17:7;;6255:43;;;6278:18;;:::i;:::-;-1:-1:-1;6325:1:7;6314:13;;6198:135::o;6338:125::-;6378:4;6406:1;6403;6400:8;6397:34;;;6411:18;;:::i;:::-;-1:-1:-1;6448:9:7;;6338:125::o;6468:209::-;6500:1;6526;6516:132;;6570:10;6565:3;6561:20;6558:1;6551:31;6605:4;6602:1;6595:15;6633:4;6630:1;6623:15;6516:132;-1:-1:-1;6662:9:7;;6468:209::o;6682:128::-;6722:3;6753:1;6749:6;6746:1;6743:13;6740:39;;;6759:18;;:::i;:::-;-1:-1:-1;6795:9:7;;6682:128::o;6815:533::-;7105:1;7101;7096:3;7092:11;7088:19;7080:6;7076:32;7065:9;7058:51;7145:6;7140:2;7129:9;7125:18;7118:34;7188:6;7183:2;7172:9;7168:18;7161:34;7231:6;7226:2;7215:9;7211:18;7204:34;7275:3;7269;7258:9;7254:19;7247:32;7039:4;7296:46;7337:3;7326:9;7322:19;7314:6;7296:46;:::i;:::-;7288:54;6815:533;-1:-1:-1;;;;;;;6815:533:7:o;7353:380::-;7432:1;7428:12;;;;7475;;;7496:61;;7550:4;7542:6;7538:17;7528:27;;7496:61;7603:2;7595:6;7592:14;7572:18;7569:38;7566:161;;;7649:10;7644:3;7640:20;7637:1;7630:31;7684:4;7681:1;7674:15;7712:4;7709:1;7702:15;7566:161;;7353:380;;;:::o;8118:277::-;8185:6;8238:2;8226:9;8217:7;8213:23;8209:32;8206:52;;;8254:1;8251;8244:12;8206:52;8286:9;8280:16;8339:5;8332:13;8325:21;8318:5;8315:32;8305:60;;8361:1;8358;8351:12;8400:274;8529:3;8567:6;8561:13;8583:53;8629:6;8624:3;8617:4;8609:6;8605:17;8583:53;:::i;:::-;8652:16;;;;;8400:274;-1:-1:-1;;8400:274:7:o

ipfs://9e175cefe054a49d4b7f510bb4806880c47a949f65ec85cca1a6732578b6a566