Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

import { IFeeCollector } from "./interfaces/IFeeCollector.sol";
import { LibAddress } from "./lib/LibAddress.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";

/// @title A smart contract for registering vaults for payments.
contract FeeCollector is IFeeCollector, Multicall {
    using LibAddress for address payable;

    address payable public guildFeeCollector;
    uint96 public guildShareBps;

    Vault[] internal vaults;

    /// @param guildFeeCollector_ The address that will receive Guild's share from the funds.
    /// @param guildShareBps_ The percentage of Guild's share expressed in basis points (e.g 500 for a 5% cut).
    constructor(address payable guildFeeCollector_, uint96 guildShareBps_) {
        guildFeeCollector = guildFeeCollector_;
        guildShareBps = guildShareBps_;
    }

    function registerVault(address owner, address token, bool multiplePayments, uint120 fee) external {
        Vault storage vault = vaults.push();
        vault.owner = owner;
        vault.token = token;
        vault.multiplePayments = multiplePayments;
        vault.fee = fee;

        emit VaultRegistered(vaults.length - 1, owner, token, fee);
    }

    function payFee(uint256 vaultId) external payable {
        if (vaultId >= vaults.length) revert VaultDoesNotExist(vaultId);

        Vault storage vault = vaults[vaultId];

        if (!vault.multiplePayments && vault.paid[msg.sender]) revert AlreadyPaid(vaultId, msg.sender);

        uint256 requiredAmount = vault.fee;
        vault.collected += uint128(requiredAmount);
        vault.paid[msg.sender] = true;

        // If the tokenAddress is zero, the payment should be in Ether, otherwise in ERC20.
        address tokenAddress = vault.token;
        if (tokenAddress == address(0)) {
            if (msg.value != requiredAmount) revert IncorrectFee(vaultId, msg.value, requiredAmount);
        } else {
            if (msg.value != 0) revert IncorrectFee(vaultId, msg.value, 0);
            if (!IERC20(tokenAddress).transferFrom(msg.sender, address(this), requiredAmount))
                revert TransferFailed(msg.sender, address(this));
        }

        emit FeeReceived(vaultId, msg.sender, requiredAmount);
    }

    function withdraw(uint256 vaultId) external {
        if (vaultId >= vaults.length) revert VaultDoesNotExist(vaultId);

        Vault storage vault = vaults[vaultId];
        uint256 collected = vault.collected;
        vault.collected = 0;

        // Calculate fees to receive. Guild's part is truncated - the remainder goes to the owner.
        uint256 guildAmount = (collected * guildShareBps) / 10000;
        uint256 ownerAmount = collected - guildAmount;

        // If the tokenAddress is zero, the collected fees are in Ether, otherwise in ERC20.
        address tokenAddress = vault.token;
        if (tokenAddress == address(0)) _withdrawEther(guildAmount, ownerAmount, vault.owner);
        else _withdrawToken(guildAmount, ownerAmount, vault.owner, tokenAddress);

        emit Withdrawn(vaultId, guildAmount, ownerAmount);
    }

    function setGuildFeeCollector(address payable newFeeCollector) external {
        if (msg.sender != guildFeeCollector) revert AccessDenied(msg.sender, guildFeeCollector);
        guildFeeCollector = newFeeCollector;
        emit GuildFeeCollectorChanged(newFeeCollector);
    }

    function setGuildShareBps(uint96 newShare) external {
        if (msg.sender != guildFeeCollector) revert AccessDenied(msg.sender, guildFeeCollector);
        guildShareBps = newShare;
        emit GuildShareBpsChanged(newShare);
    }

    function setVaultDetails(uint256 vaultId, address newOwner, bool newMultiplePayments, uint120 newFee) external {
        if (vaultId >= vaults.length) revert VaultDoesNotExist(vaultId);
        Vault storage vault = vaults[vaultId];

        if (msg.sender != vault.owner) revert AccessDenied(msg.sender, vault.owner);

        vault.owner = newOwner;
        vault.multiplePayments = newMultiplePayments;
        vault.fee = newFee;

        emit VaultDetailsChanged(vaultId);
    }

    function getVault(
        uint256 vaultId
    ) external view returns (address owner, address token, bool multiplePayments, uint120 fee, uint128 collected) {
        if (vaultId >= vaults.length) revert VaultDoesNotExist(vaultId);
        Vault storage vault = vaults[vaultId];
        return (vault.owner, vault.token, vault.multiplePayments, vault.fee, vault.collected);
    }

    function hasPaid(uint256 vaultId, address account) external view returns (bool paid) {
        if (vaultId >= vaults.length) revert VaultDoesNotExist(vaultId);
        return vaults[vaultId].paid[account];
    }

    function _withdrawEther(uint256 guildAmount, uint256 ownerAmount, address eventOwner) internal {
        guildFeeCollector.sendEther(guildAmount);
        payable(eventOwner).sendEther(ownerAmount);
    }

    function _withdrawToken(
        uint256 guildAmount,
        uint256 ownerAmount,
        address eventOwner,
        address tokenAddress
    ) internal {
        IERC20 token = IERC20(tokenAddress);
        if (!token.transfer(guildFeeCollector, guildAmount)) revert TransferFailed(address(this), guildFeeCollector);
        if (!token.transfer(eventOwner, ownerAmount)) revert TransferFailed(address(this), eventOwner);
    }
}

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

/// @title A smart contract for registering vaults for payments.
interface IFeeCollector {
    struct Vault {
        address owner;
        address token;
        bool multiplePayments;
        uint120 fee;
        uint128 collected;
        mapping(address => bool) paid;
    }

    /// @notice Registers a vault and it's fee.
    /// @param owner The address that receives the fees from the payment.
    /// @param token The zero address for Ether, otherwise an ERC20 token.
    /// @param multiplePayments Whether the fee can be paid multiple times.
    /// @param fee The amount of fee to pay in base units.
    function registerVault(address owner, address token, bool multiplePayments, uint120 fee) external;

    /// @notice Registers the paid fee, both in Ether or ERC20.
    /// @param vaultId The id of the vault to pay to.
    function payFee(uint256 vaultId) external payable;

    /// @notice Sets the address that receives Guild's share from the funds.
    /// @dev Callable only by the current Guild fee collector.
    /// @param newFeeCollector The new address of guildFeeCollector.
    function setGuildFeeCollector(address payable newFeeCollector) external;

    /// @notice Sets Guild's share from the funds.
    /// @dev Callable only by the Guild fee collector.
    /// @param newShare The percentual value expressed in basis points.
    function setGuildShareBps(uint96 newShare) external;

    /// @notice Changes the details of a vault.
    /// @dev Callable only by the owner of the vault to be changed.
    /// @param vaultId The id of the vault whose details should be changed.
    /// @param newOwner The address that will receive the fees from now on.
    /// @param newMultiplePayments Whether the fee can be paid multiple times from now on.
    /// @param newFee The amount of fee to pay in base units from now on.
    function setVaultDetails(uint256 vaultId, address newOwner, bool newMultiplePayments, uint120 newFee) external;

    /// @notice Distributes the funds from a vault to the fee collectors and the owner.
    /// @param vaultId The id of the vault whose funds should be distributed.
    function withdraw(uint256 vaultId) external;

    /// @notice Returns a vault's details.
    /// @param vaultId The id of the queried vault.
    /// @return owner The owner of the vault who recieves the funds.
    /// @return token The address of the token to receive funds in (the zero address in case of Ether).
    /// @return multiplePayments Whether the fee can be paid multiple times.
    /// @return fee The amount of required funds in base units.
    /// @return collected The amount of already collected funds.
    function getVault(
        uint256 vaultId
    ) external view returns (address owner, address token, bool multiplePayments, uint120 fee, uint128 collected);

    /// @notice Returns if an account has paid the fee to a vault.
    /// @param vaultId The id of the queried vault.
    /// @param account The address of the queried account.
    function hasPaid(uint256 vaultId, address account) external view returns (bool paid);

    /// @notice Returns the address that receives Guild's share from the funds.
    function guildFeeCollector() external view returns (address payable);

    /// @notice Returns the percentage of Guild's share expressed in basis points.
    function guildShareBps() external view returns (uint96);

    /// @notice Event emitted when a call to {payFee} succeeds.
    /// @param vaultId The id of the vault that received the payment.
    /// @param account The address of the account that paid.
    /// @param amount The amount of fee received in base units.
    event FeeReceived(uint256 indexed vaultId, address indexed account, uint256 amount);

    /// @notice Event emitted when the Guild fee collector address is changed.
    /// @param newFeeCollector The address to change guildFeeCollector to.
    event GuildFeeCollectorChanged(address newFeeCollector);

    /// @notice Event emitted when the share of the Guild fee collector changes.
    /// @param newShare The new value of guildShareBps.
    event GuildShareBpsChanged(uint96 newShare);

    /// @notice Event emitted when a vault's details are changed.
    /// @param vaultId The id of the altered vault.
    event VaultDetailsChanged(uint256 vaultId);

    /// @notice Event emitted when a new vault is registered.
    /// @param owner The address that receives the fees from the payment.
    /// @param token The zero address for Ether, otherwise an ERC20 token.
    /// @param fee The amount of fee to pay in base units.
    event VaultRegistered(uint256 vaultId, address indexed owner, address indexed token, uint256 fee);

    /// @notice Event emitted when funds are withdrawn by a vault owner.
    /// @param vaultId The id of the vault.
    /// @param guildAmount The amount received by the Guild fee collector in base units.
    /// @param ownerAmount The amount received by the vault's owner in base units.
    event Withdrawn(uint256 indexed vaultId, uint256 guildAmount, uint256 ownerAmount);

    /// @notice Error thrown when multiple payments aren't enabled, but the sender attempts to pay repeatedly.
    /// @param vaultId The id of the vault.
    /// @param sender The sender of the transaction.
    error AlreadyPaid(uint256 vaultId, address sender);

    /// @notice Error thrown when an incorrect amount of fee is attempted to be paid.
    /// @dev requiredAmount might be 0 in cases when an ERC20 payment was expected but Ether was received, too.
    /// @param vaultId The id of the vault.
    /// @param paid The amount of funds received.
    /// @param requiredAmount The amount of fees required by the vault.
    error IncorrectFee(uint256 vaultId, uint256 paid, uint256 requiredAmount);

    /// @notice Error thrown when a function is attempted to be called by the wrong address.
    /// @param sender The address that sent the transaction.
    /// @param owner The address that is allowed to call the function.
    error AccessDenied(address sender, address owner);

    /// @notice Error thrown when an ERC20 transfer failed.
    /// @param from The sender of the token.
    /// @param to The recipient of the token.
    error TransferFailed(address from, address to);

    /// @notice Error thrown when a vault does not exist.
    /// @param vaultId The id of the requested vault.
    error VaultDoesNotExist(uint256 vaultId);
}

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

/// @title Library for functions related to addresses.
library LibAddress {
    /// @notice Error thrown when sending ether fails.
    /// @param recipient The address that could not receive the ether.
    error FailedToSendEther(address recipient);

    /// @notice Send ether to an address, forwarding all available gas and reverting on errors.
    /// @param recipient The recipient of the ether.
    /// @param amount The amount of ether to send in base units.
    function sendEther(address payable recipient, uint256 amount) internal {
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, ) = recipient.call{ value: amount }("");
        if (!success) revert FailedToSendEther(recipient);
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./Address.sol";

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 *
 * _Available since v4.1._
 */
abstract contract Multicall {
    /**
     * @dev Receives and executes a batch of function calls on this contract.
     */
    function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            results[i] = Address.functionDelegateCall(address(this), data[i]);
        }
        return results;
    }
}

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"guildFeeCollector_","type":"address"},{"internalType":"uint96","name":"guildShareBps_","type":"uint96"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"AccessDenied","type":"error"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"address","name":"sender","type":"address"}],"name":"AlreadyPaid","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"FailedToSendEther","type":"error"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"uint256","name":"paid","type":"uint256"},{"internalType":"uint256","name":"requiredAmount","type":"uint256"}],"name":"IncorrectFee","type":"error"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"}],"name":"TransferFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"VaultDoesNotExist","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newFeeCollector","type":"address"}],"name":"GuildFeeCollectorChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint96","name":"newShare","type":"uint96"}],"name":"GuildShareBpsChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"VaultDetailsChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"VaultRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"guildAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownerAmount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"getVault","outputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"multiplePayments","type":"bool"},{"internalType":"uint120","name":"fee","type":"uint120"},{"internalType":"uint128","name":"collected","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guildFeeCollector","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guildShareBps","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"hasPaid","outputs":[{"internalType":"bool","name":"paid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"payFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"multiplePayments","type":"bool"},{"internalType":"uint120","name":"fee","type":"uint120"}],"name":"registerVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newFeeCollector","type":"address"}],"name":"setGuildFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"newShare","type":"uint96"}],"name":"setGuildShareBps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bool","name":"newMultiplePayments","type":"bool"},{"internalType":"uint120","name":"newFee","type":"uint120"}],"name":"setVaultDetails","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

365:5085:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3194:277;;;;;;;;;;-1:-1:-1;3194:277:0;;;;;:::i;:::-;;:::i;:::-;;2345:843;;;;;;;;;;-1:-1:-1;2345:843:0;;;;;:::i;:::-;;:::i;464:40::-;;;;;;;;;;-1:-1:-1;464:40:0;;;;-1:-1:-1;;;;;464:40:0;;;;;;-1:-1:-1;;;;;791:32:6;;;773:51;;761:2;746:18;464:40:0;;;;;;;;3718:483;;;;;;;;;;-1:-1:-1;3718:483:0;;;;;:::i;:::-;;:::i;3477:235::-;;;;;;;;;;-1:-1:-1;3477:235:0;;;;;:::i;:::-;;:::i;510:27::-;;;;;;;;;;-1:-1:-1;510:27:0;;;;-1:-1:-1;;;510:27:0;;-1:-1:-1;;;;;510:27:0;;;;;;-1:-1:-1;;;;;2146:39:6;;;2128:58;;2116:2;2101:18;510:27:0;1984:208:6;4207:379:0;;;;;;;;;;-1:-1:-1;4207:379:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2506:15:6;;;2488:34;;2558:15;;;;2553:2;2538:18;;2531:43;2617:14;;2610:22;2590:18;;;2583:50;;;;-1:-1:-1;;;;;2669:45:6;;;2664:2;2649:18;;2642:73;-1:-1:-1;;;;;2752:47:6;2746:3;2731:19;;2724:76;2437:3;2422:19;4207:379:0;2197:609:6;407:308:5;;;;;;;;;;-1:-1:-1;407:308:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;952:353:0:-;;;;;;;;;;-1:-1:-1;952:353:0;;;;;:::i;:::-;;:::i;1311:1028::-;;;;;;:::i;:::-;;:::i;4592:211::-;;;;;;;;;;-1:-1:-1;4592:211:0;;;;;:::i;:::-;;:::i;:::-;;;5889:14:6;;5882:22;5864:41;;5852:2;5837:18;4592:211:0;5724:187:6;3194:277:0;3294:17;;-1:-1:-1;;;;;3294:17:0;3280:10;:31;3276:87;;3345:17;;3320:43;;-1:-1:-1;;;3320:43:0;;3333:10;3320:43;;;6136:34:6;-1:-1:-1;;;;;3345:17:0;;;6186:18:6;;;6179:43;6071:18;;3320:43:0;;;;;;;;3276:87;3373:17;:35;;-1:-1:-1;;;;;;3373:35:0;-1:-1:-1;;;;;3373:35:0;;;;;;;;3423:41;;773:51:6;;;3423:41:0;;761:2:6;746:18;3423:41:0;;;;;;;;3194:277;:::o;2345:843::-;2414:6;:13;2403:24;;2399:63;;2436:26;;-1:-1:-1;;;2436:26:0;;;;;6595:25:6;;;6568:18;;2436:26:0;6449:177:6;2399:63:0;2473:19;2495:6;2502:7;2495:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;2540;;;;;-1:-1:-1;;;;2565:19:0;;;;;2729:13;;2495:15;;-1:-1:-1;;;;2540:15:0;;-1:-1:-1;;;;;2540:15:0;;2495;2746:5;;2717:25;;-1:-1:-1;;;2729:13:0;;-1:-1:-1;;;;;2729:13:0;2540:15;2717:25;:::i;:::-;2716:35;;;;:::i;:::-;2694:57;-1:-1:-1;2761:19:0;2783:23;2694:57;2783:9;:23;:::i;:::-;2933:11;;;;2761:45;;-1:-1:-1;;;;;;2933:11:0;;2954:167;;3027:11;;2986:53;;3001:11;;3014;;-1:-1:-1;;;;;3027:11:0;2986:14;:53::i;:::-;2954:167;;;3095:11;;3054:67;;3069:11;;3082;;-1:-1:-1;;;;;3095:11:0;3108:12;3054:14;:67::i;:::-;3137:44;;;7597:25:6;;;7653:2;7638:18;;7631:34;;;3147:7:0;;3137:44;;7570:18:6;3137:44:0;;;;;;;2389:799;;;;;2345:843;:::o;3718:483::-;3854:6;:13;3843:24;;3839:63;;3876:26;;-1:-1:-1;;;3876:26:0;;;;;6595:25:6;;;6568:18;;3876:26:0;6449:177:6;3839:63:0;3912:19;3934:6;3941:7;3934:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;3978:11;;3934:15;;-1:-1:-1;;;;;;3978:11:0;3964:10;:25;3960:75;;4023:11;;3998:37;;-1:-1:-1;;;3998:37:0;;4011:10;3998:37;;;6136:34:6;-1:-1:-1;;;;;4023:11:0;;;6186:18:6;;;6179:43;6071:18;;3998:37:0;5916:312:6;3960:75:0;4046:22;;-1:-1:-1;;;;;;4046:22:0;-1:-1:-1;;;;;4046:22:0;;;;;-1:-1:-1;4078:22:0;;:44;;-1:-1:-1;;;;4078:44:0;-1:-1:-1;;;4078:44:0;;;;;;;4132:9;;;:18;;-1:-1:-1;;;;;;4132:18:0;-1:-1:-1;;;;;4132:18:0;;;;;4166:28;;6595:25:6;;;4166:28:0;;6583:2:6;6568:18;4166:28:0;;;;;;;3829:372;3718:483;;;;:::o;3477:235::-;3557:17;;-1:-1:-1;;;;;3557:17:0;3543:10;:31;3539:87;;3608:17;;3583:43;;-1:-1:-1;;;3583:43:0;;3596:10;3583:43;;;6136:34:6;-1:-1:-1;;;;;3608:17:0;;;6186:18:6;;;6179:43;6071:18;;3583:43:0;5916:312:6;3539:87:0;3636:13;:24;;-1:-1:-1;;;;;3636:24:0;-1:-1:-1;;;;;;;;3636:24:0;;;;;;;;;;;;3675:30;;2128:58:6;;;3675:30:0;;2116:2:6;2101:18;3675:30:0;1984:208:6;4207:379:0;4279:13;4294;4309:21;4332:11;4345:17;4389:6;:13;;;;4378:7;:24;4374:63;;4411:26;;-1:-1:-1;;;4411:26:0;;;;;6595:25:6;;;6568:18;;4411:26:0;6449:177:6;4374:63:0;4447:19;4469:6;4476:7;4469:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;4502:11;;;4515;;;4552:9;;;;;-1:-1:-1;;;;;4502:11:0;;;;4515;;;;-1:-1:-1;;;;4528:22:0;;;;;;-1:-1:-1;;;;;;4552:9:0;;;-1:-1:-1;;;;4563:15:0;;;-1:-1:-1;;;;;4563:15:0;;-1:-1:-1;4207:379:0;-1:-1:-1;;;4207:379:0:o;407:308:5:-;475:22;531:4;519:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;509:34;;558:9;553:132;573:15;;;553:132;;;622:52;659:4;666;;671:1;666:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;622:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;622:28:5;;-1:-1:-1;;;622:52:5:i;:::-;609:7;617:1;609:10;;;;;;;;:::i;:::-;;;;;;:65;;;;590:3;;;;;:::i;:::-;;;;553:132;;;;407:308;;;;;:::o;952:353:0:-;1082:6;:13;;;;;;;-1:-1:-1;1082:13:0;;;;;;;;;;;1105:19;;-1:-1:-1;;;;;;1105:19:0;-1:-1:-1;;;;;1105:19:0;;;;;;;;1134:11;;;:19;;;;;-1:-1:-1;;;;;;1163:41:0;;;;;-1:-1:-1;;;1163:41:0;;;;;;;1214:9;;;;:15;;-1:-1:-1;;;;;;1214:15:0;-1:-1:-1;;;;;1214:15:0;;;;;1261:13;;1082;;1105:19;;1245:53;;1261:17;;;:::i;:::-;1245:53;;;8957:25:6;;;-1:-1:-1;;;;;9018:45:6;;9013:2;8998:18;;8991:73;8930:18;1245:53:0;;;;;;;1050:255;952:353;;;;:::o;1311:1028::-;1386:6;:13;1375:24;;1371:63;;1408:26;;-1:-1:-1;;;1408:26:0;;;;;6595:25:6;;;6568:18;;1408:26:0;6449:177:6;1371:63:0;1445:19;1467:6;1474:7;1467:15;;;;;;;;:::i;:::-;;;;;;;;;;;1445:37;;1498:5;:22;;;;;;;;;;;;1497:23;:49;;;;-1:-1:-1;1535:10:0;1524:22;;;;:10;;;:22;;;;;;;;1497:49;1493:94;;;1555:32;;-1:-1:-1;;;1555:32:0;;;;;9249:25:6;;;1576:10:0;9290:18:6;;;9283:60;9222:18;;1555:32:0;9075:274:6;1493:94:0;1623:9;;;;;-1:-1:-1;;;;;1623:9:0;;;;;1642:15;;:42;;1623:9;;-1:-1:-1;;;1642:42:0;;-1:-1:-1;;;;;1642:42:0;;:::i;:::-;;;-1:-1:-1;;;;;1642:42:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1705:10:0;-1:-1:-1;1694:22:0;;;:10;;;:22;;;;;:29;;-1:-1:-1;;1694:29:0;-1:-1:-1;1694:29:0;;;;;;1849:11;;;-1:-1:-1;;;;;1849:11:0;;1870:399;;1933:14;1920:9;:27;1916:88;;1956:48;;-1:-1:-1;;;1956:48:0;;;;;9758:25:6;;;1978:9:0;9799:18:6;;;9792:34;9842:18;;;9835:34;;;9731:18;;1956:48:0;9556:319:6;1916:88:0;1870:399;;;2039:9;:14;2035:62;;2062:35;;-1:-1:-1;;;2062:35:0;;;;;9758:25:6;;;2084:9:0;9799:18:6;;;9792:34;2095:1:0;9842:18:6;;;9835:34;9731:18;;2062:35:0;9556:319:6;2035:62:0;2116:76;;-1:-1:-1;;;2116:76:0;;2150:10;2116:76;;;10452:34:6;2170:4:0;10502:18:6;;;10495:43;10554:18;;;10547:34;;;-1:-1:-1;;;;;2116:33:0;;;;;10387:18:6;;2116:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2111:147;;2217:41;;-1:-1:-1;;;2217:41:0;;2232:10;2217:41;;;6136:34:6;2252:4:0;6186:18:6;;;6179:43;6071:18;;2217:41:0;5916:312:6;2111:147:0;2284:48;;6595:25:6;;;2305:10:0;;2296:7;;2284:48;;6583:2:6;6568:18;2284:48:0;;;;;;;1361:978;;;1311:1028;:::o;4592:211::-;4702:6;:13;4666:9;;4691:24;;4687:63;;4724:26;;-1:-1:-1;;;4724:26:0;;;;;6595:25:6;;;6568:18;;4724:26:0;6449:177:6;4687:63:0;4767:6;4774:7;4767:15;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;4767:29:0;;;;:20;:15;;;;;:20;;;;:29;;;;;;;;;-1:-1:-1;4592:211:0;;;;:::o;4809:204::-;4914:17;;:40;;-1:-1:-1;;;;;4914:17:0;4942:11;4914:27;:40::i;:::-;4964:42;-1:-1:-1;;;;;4964:29:0;;4994:11;4964:29;:42::i;:::-;4809:204;;;:::o;5019:429::-;5184:12;5249:17;5234:46;;-1:-1:-1;;;5234:46:0;;-1:-1:-1;;;;;5249:17:0;;;5234:46;;;11024:51:6;11091:18;;;11084:34;;;5206:12:0;;5234:14;;;;;10997:18:6;;5234:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5229:108;;5319:17;;5289:48;;-1:-1:-1;;;5289:48:0;;5312:4;5289:48;;;6136:34:6;-1:-1:-1;;;;;5319:17:0;;;6186:18:6;;;6179:43;6071:18;;5289:48:0;5916:312:6;5229:108:0;5352:39;;-1:-1:-1;;;5352:39:0;;-1:-1:-1;;;;;11042:32:6;;;5352:39:0;;;11024:51:6;11091:18;;;11084:34;;;5352:14:0;;;;;10997:18:6;;5352:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5347:94;;5400:41;;-1:-1:-1;;;5400:41:0;;5423:4;5400:41;;;6136:34:6;-1:-1:-1;;;;;6206:15:6;;6186:18;;;6179:43;6071:18;;5400:41:0;5916:312:6;5347:94:0;5174:274;5019:429;;;;:::o;6469:198:4:-;6552:12;6583:77;6604:6;6612:4;6583:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6576:84;6469:198;-1:-1:-1;;;6469:198:4:o;526:260:2:-;667:12;685:9;-1:-1:-1;;;;;685:14:2;708:6;685:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;666:54;;;735:7;730:49;;751:28;;-1:-1:-1;;;751:28:2;;-1:-1:-1;;;;;791:32:6;;751:28:2;;;773:51:6;746:18;;751:28:2;611:219:6;6853:325:4;6994:12;7019;7033:23;7060:6;-1:-1:-1;;;;;7060:19:4;7080:4;7060:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7018:67;;;;7102:69;7129:6;7137:7;7146:10;7158:12;7102:26;:69::i;:::-;7095:76;6853:325;-1:-1:-1;;;;;;6853:325:4:o;7466:628::-;7646:12;7674:7;7670:418;;;7701:10;:17;7722:1;7701:22;7697:286;;-1:-1:-1;;;;;1465:19:4;;;7908:60;;;;-1:-1:-1;;;7908:60:4;;12112:2:6;7908:60:4;;;12094:21:6;12151:2;12131:18;;;12124:30;12190:31;12170:18;;;12163:59;12239:18;;7908:60:4;11910:353:6;7908:60:4;-1:-1:-1;8003:10:4;7996:17;;7670:418;8044:33;8052:10;8064:12;8044:7;:33::i;:::-;7466:628;;;;;;:::o;8616:540::-;8775:17;;:21;8771:379;;9003:10;8997:17;9059:15;9046:10;9042:2;9038:19;9031:44;8771:379;9126:12;9119:20;;-1:-1:-1;;;9119:20:4;;;;;;;;:::i;14:139:6:-;-1:-1:-1;;;;;97:31:6;;87:42;;77:70;;143:1;140;133:12;77:70;14:139;:::o;158:263::-;225:6;278:2;266:9;257:7;253:23;249:32;246:52;;;294:1;291;284:12;246:52;333:9;320:23;352:39;385:5;352:39;:::i;426:180::-;485:6;538:2;526:9;517:7;513:23;509:32;506:52;;;554:1;551;544:12;506:52;-1:-1:-1;577:23:6;;426:180;-1:-1:-1;426:180:6:o;835:118::-;921:5;914:13;907:21;900:5;897:32;887:60;;943:1;940;933:12;958:186;1026:20;;-1:-1:-1;;;;;1075:44:6;;1065:55;;1055:83;;1134:1;1131;1124:12;1055:83;958:186;;;:::o;1149:533::-;1232:6;1240;1248;1256;1309:3;1297:9;1288:7;1284:23;1280:33;1277:53;;;1326:1;1323;1316:12;1277:53;1362:9;1349:23;1339:33;;1422:2;1411:9;1407:18;1394:32;1435:39;1468:5;1435:39;:::i;:::-;1493:5;-1:-1:-1;1550:2:6;1535:18;;1522:32;1563:30;1522:32;1563:30;:::i;:::-;1612:7;-1:-1:-1;1638:38:6;1672:2;1657:18;;1638:38;:::i;:::-;1628:48;;1149:533;;;;;;;:::o;1687:292::-;1745:6;1798:2;1786:9;1777:7;1773:23;1769:32;1766:52;;;1814:1;1811;1804:12;1766:52;1853:9;1840:23;-1:-1:-1;;;;;1896:5:6;1892:38;1885:5;1882:49;1872:77;;1945:1;1942;1935:12;2811:626;2908:6;2916;2969:2;2957:9;2948:7;2944:23;2940:32;2937:52;;;2985:1;2982;2975:12;2937:52;3025:9;3012:23;3054:18;3095:2;3087:6;3084:14;3081:34;;;3111:1;3108;3101:12;3081:34;3149:6;3138:9;3134:22;3124:32;;3194:7;3187:4;3183:2;3179:13;3175:27;3165:55;;3216:1;3213;3206:12;3165:55;3256:2;3243:16;3282:2;3274:6;3271:14;3268:34;;;3298:1;3295;3288:12;3268:34;3351:7;3346:2;3336:6;3333:1;3329:14;3325:2;3321:23;3317:32;3314:45;3311:65;;;3372:1;3369;3362:12;3311:65;3403:2;3395:11;;;;;3425:6;;-1:-1:-1;2811:626:6;;-1:-1:-1;;;;2811:626:6:o;3442:250::-;3527:1;3537:113;3551:6;3548:1;3545:13;3537:113;;;3627:11;;;3621:18;3608:11;;;3601:39;3573:2;3566:10;3537:113;;;-1:-1:-1;;3684:1:6;3666:16;;3659:27;3442:250::o;3697:270::-;3738:3;3776:5;3770:12;3803:6;3798:3;3791:19;3819:76;3888:6;3881:4;3876:3;3872:14;3865:4;3858:5;3854:16;3819:76;:::i;:::-;3949:2;3928:15;-1:-1:-1;;3924:29:6;3915:39;;;;3956:4;3911:50;;3697:270;-1:-1:-1;;3697:270:6:o;3972:800::-;4132:4;4161:2;4201;4190:9;4186:18;4231:2;4220:9;4213:21;4254:6;4289;4283:13;4320:6;4312;4305:22;4358:2;4347:9;4343:18;4336:25;;4420:2;4410:6;4407:1;4403:14;4392:9;4388:30;4384:39;4370:53;;4458:2;4450:6;4446:15;4479:1;4489:254;4503:6;4500:1;4497:13;4489:254;;;4596:2;4592:7;4580:9;4572:6;4568:22;4564:36;4559:3;4552:49;4624:39;4656:6;4647;4641:13;4624:39;:::i;:::-;4614:49;-1:-1:-1;4721:12:6;;;;4686:15;;;;4525:1;4518:9;4489:254;;;-1:-1:-1;4760:6:6;;3972:800;-1:-1:-1;;;;;;;3972:800:6:o;4777:614::-;4860:6;4868;4876;4884;4937:3;4925:9;4916:7;4912:23;4908:33;4905:53;;;4954:1;4951;4944:12;4905:53;4993:9;4980:23;5012:39;5045:5;5012:39;:::i;:::-;5070:5;-1:-1:-1;5127:2:6;5112:18;;5099:32;5140:41;5099:32;5140:41;:::i;5396:323::-;5464:6;5472;5525:2;5513:9;5504:7;5500:23;5496:32;5493:52;;;5541:1;5538;5531:12;5493:52;5577:9;5564:23;5554:33;;5637:2;5626:9;5622:18;5609:32;5650:39;5683:5;5650:39;:::i;:::-;5708:5;5698:15;;;5396:323;;;;;:::o;6631:127::-;6692:10;6687:3;6683:20;6680:1;6673:31;6723:4;6720:1;6713:15;6747:4;6744:1;6737:15;6763:127;6824:10;6819:3;6815:20;6812:1;6805:31;6855:4;6852:1;6845:15;6879:4;6876:1;6869:15;6895:168;6968:9;;;6999;;7016:15;;;7010:22;;6996:37;6986:71;;7037:18;;:::i;7068:217::-;7108:1;7134;7124:132;;7178:10;7173:3;7169:20;7166:1;7159:31;7213:4;7210:1;7203:15;7241:4;7238:1;7231:15;7124:132;-1:-1:-1;7270:9:6;;7068:217::o;7290:128::-;7357:9;;;7378:11;;;7375:37;;;7392:18;;:::i;7985:127::-;8046:10;8041:3;8037:20;8034:1;8027:31;8077:4;8074:1;8067:15;8101:4;8098:1;8091:15;8117:521;8194:4;8200:6;8260:11;8247:25;8354:2;8350:7;8339:8;8323:14;8319:29;8315:43;8295:18;8291:68;8281:96;;8373:1;8370;8363:12;8281:96;8400:33;;8452:20;;;-1:-1:-1;8495:18:6;8484:30;;8481:50;;;8527:1;8524;8517:12;8481:50;8560:4;8548:17;;-1:-1:-1;8591:14:6;8587:27;;;8577:38;;8574:58;;;8628:1;8625;8618:12;8574:58;8117:521;;;;;:::o;8643:135::-;8682:3;8703:17;;;8700:43;;8723:18;;:::i;:::-;-1:-1:-1;8770:1:6;8759:13;;8643:135::o;9354:197::-;-1:-1:-1;;;;;9476:10:6;;;9488;;;9472:27;;9511:11;;;9508:37;;;9525:18;;:::i;10592:245::-;10659:6;10712:2;10700:9;10691:7;10687:23;10683:32;10680:52;;;10728:1;10725;10718:12;10680:52;10760:9;10754:16;10779:28;10801:5;10779:28;:::i;11618:287::-;11747:3;11785:6;11779:13;11801:66;11860:6;11855:3;11848:4;11840:6;11836:17;11801:66;:::i;:::-;11883:16;;;;;11618:287;-1:-1:-1;;11618:287:6:o;12268:219::-;12417:2;12406:9;12399:21;12380:4;12437:44;12477:2;12466:9;12462:18;12454:6;12437:44;:::i

ipfs://a8c5d178e1abf974c50c36952d97a7837ca0fea7a4fd22f8d97c079fbcbc10dd