Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Utils
•    - function recoverSigner(bytes32 _signe ...
•    - function functionPrefix(bytes memory ...
•    - function ceil(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IWallet
•    - function owner()
•    - function modules()
•    - function setOwner(address _newOwner)
•    - function authorised(address _module)
•    - function enabled(bytes4 _sig)
•    - function authoriseModule(address _mod ...
•    - function enableStaticCall(address _mo ...
• interface IModuleRegistry
•    - function registerModule(address _modu ...
•    - function deregisterModule(address _mo ...
•    - function registerUpgrader(address _up ...
•    - function deregisterUpgrader(address _ ...
•    - function recoverToken(address _token)
•    - function moduleInfo(address _module)
•    - function upgraderInfo(address _upgrad ...
•    - function isRegisteredModule(address _ ...
•    - function isRegisteredModule(address[] ...
•    - function isRegisteredUpgrader(address ...
• interface ILockStorage
•    - function isLocked(address _wallet)
•    - function getLock(address _wallet)
•    - function getLocker(address _wallet)
•    - function setLock(address _wallet, add ...
• interface IFeature
•    - function recoverToken(address _token)
•    - function init(address _wallet)
•    - function isFeatureAuthorisedInVersion ...
•    - function getRequiredSignatures(addres ...
•    - function getStaticCallSignatures()
• interface ERC20
•    - function totalSupply()
•    - function decimals()
•    - function balanceOf(address tokenOwner ...
•    - function allowance(address tokenOwner ...
•    - function transfer(address to, uint to ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface ILimitStorage
•    - function setLimit(address _wallet, Li ...
•    - function getLimit(address _wallet)
•    - function setDailySpent(address _walle ...
•    - function getDailySpent(address _walle ...
•    - function setLimitAndDailySpent(addres ...
•    - function getLimitAndDailySpent(addres ...
• interface IVersionManager
•    - function isFeatureAuthorised(address ...
•    - function checkAuthorisedFeatureAndInv ...
•    - function setOwner(address _wallet, ad ...
•    - function invokeStorage(address _walle ...
•    - function upgradeWallet(address _walle ...
•  contract BaseFeature is IFeature
•    - function recoverToken(address _token)
•    - function init(address _wallet)
•    - function getRequiredSignatures(addres ...
•    - function getStaticCallSignatures()
•    - function isFeatureAuthorisedInVersion ...
•    - function verifyData(address _wallet, ...
•    - function isOwner(address _wallet, add ...
•    - function verifyOwnerOrAuthorisedFeatu ...
•    - function invokeWallet(address _wallet ...
• library GuardianUtils
•    - function isGuardianOrGuardianSigner(a ...
•    - function isContract(address _addr)
•    - function isGuardianOwner(address _gua ...
• interface ITokenPriceRegistry
•    - function getTokenPrice(address _token ...
•    - function isTokenTradable(address _tok ...
• library LimitUtils
•    - function changeLimit(
•    - function disableLimit(
•    - function isLimitDisabled(ILimitStorag ...
•    - function checkAndUpdateDailySpent(
•    - function resetDailySpent(IVersionMana ...
•    - function getEtherValue(ITokenPriceReg ...
•    - function currentLimit(ILimitStorage.L ...
•    - function safe128(uint256 _num)
•    - function safe64(uint256 _num)
•    - function setLimit(
•    - function setDailySpent(
• interface IGuardianStorage
•    - function addGuardian(address _wallet, ...
•    - function revokeGuardian(address _wall ...
•    - function isGuardian(address _wallet, ...
•    - function isLocked(address _wallet)
•    - function getLock(address _wallet)
•    - function getLocker(address _wallet)
•    - function setLock(address _wallet, uin ...
•    - function getGuardians(address _wallet ...
•    - function guardianCount(address _walle ...
•  contract RelayerManager is BaseFea ... *
•    - function execute(
•    - function getNonce(address _wallet)
•    - function isExecutedTx(address _wallet ...
•    - function getSignHash(
•    - function checkAndUpdateUniqueness(
•    - function validateSignatures(
•    - function refund(
•    - function getChainId()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-11-16
*/

pragma experimental ABIEncoderV2;
// File: contracts/modules/common/Utils.sol
// Copyright (C) 2020  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// SPDX-License-Identifier: GPL-3.0-only
/**
 * @title Utils
 * @notice Common utility methods used by modules.
 */
library Utils {
    /**
    * @notice Helper method to recover the signer at a given position from a list of concatenated signatures.
    * @param _signedHash The signed hash
    * @param _signatures The concatenated signatures.
    * @param _index The index of the signature to recover.
    */
    function recoverSigner(bytes32 _signedHash, bytes memory _signatures, uint _index) internal pure returns (address) {
        uint8 v;
        bytes32 r;
        bytes32 s;
        // we jump 32 (0x20) as the first slot of bytes contains the length
        // we jump 65 (0x41) per signature
        // for v we load 32 bytes ending with v (the first 31 come from s) then apply a mask
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(_signatures, add(0x20,mul(0x41,_index))))
            s := mload(add(_signatures, add(0x40,mul(0x41,_index))))
            v := and(mload(add(_signatures, add(0x41,mul(0x41,_index)))), 0xff)
        }
        require(v == 27 || v == 28);
        address recoveredAddress = ecrecover(_signedHash, v, r, s);
        require(recoveredAddress != address(0), "Utils: ecrecover returned 0");
        return recoveredAddress;
    }
    /**
    * @notice Helper method to parse data and extract the method signature.
    */
    function functionPrefix(bytes memory _data) internal pure returns (bytes4 prefix) {
        require(_data.length >= 4, "RM: Invalid functionPrefix");
        // solhint-disable-next-line no-inline-assembly
        assembly {
            prefix := mload(add(_data, 0x20))
        }
    }
    /**
    * @notice Returns ceil(a / b).
    */
    function ceil(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a / b;
        if (a % b == 0) {
            return c;
        } else {
            return c + 1;
        }
    }
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a < b) {
            return a;
        }
        return b;
    }
}
// File: @openzeppelin/contracts/math/SafeMath.sol
/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }
    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }
    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }
    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }
    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }
    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }
    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}
// File: contracts/wallet/IWallet.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
/**
 * @title IWallet
 * @notice Interface for the BaseWallet
 */
interface IWallet {
    /**
     * @notice Returns the wallet owner.
     * @return The wallet owner address.
     */
    function owner() external view returns (address);
    /**
     * @notice Returns the number of authorised modules.
     * @return The number of authorised modules.
     */
    function modules() external view returns (uint);
    /**
     * @notice Sets a new owner for the wallet.
     * @param _newOwner The new owner.
     */
    function setOwner(address _newOwner) external;
    /**
     * @notice Checks if a module is authorised on the wallet.
     * @param _module The module address to check.
     * @return `true` if the module is authorised, otherwise `false`.
     */
    function authorised(address _module) external view returns (bool);
    /**
     * @notice Returns the module responsible for a static call redirection.
     * @param _sig The signature of the static call.
     * @return the module doing the redirection
     */
    function enabled(bytes4 _sig) external view returns (address);
    /**
     * @notice Enables/Disables a module.
     * @param _module The target module.
     * @param _value Set to `true` to authorise the module.
     */
    function authoriseModule(address _module, bool _value) external;
    /**
    * @notice Enables a static method by specifying the target module to which the call must be delegated.
    * @param _module The target module.
    * @param _method The static method signature.
    */
    function enableStaticCall(address _module, bytes4 _method) external;
}
// File: contracts/infrastructure/IModuleRegistry.sol
// Copyright (C) 2020  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
/**
 * @title IModuleRegistry
 * @notice Interface for the registry of authorised modules.
 */
interface IModuleRegistry {
    function registerModule(address _module, bytes32 _name) external;
    function deregisterModule(address _module) external;
    function registerUpgrader(address _upgrader, bytes32 _name) external;
    function deregisterUpgrader(address _upgrader) external;
    function recoverToken(address _token) external;
    function moduleInfo(address _module) external view returns (bytes32);
    function upgraderInfo(address _upgrader) external view returns (bytes32);
    function isRegisteredModule(address _module) external view returns (bool);
    function isRegisteredModule(address[] calldata _modules) external view returns (bool);
    function isRegisteredUpgrader(address _upgrader) external view returns (bool);
}
// File: contracts/infrastructure/storage/ILockStorage.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
interface ILockStorage {
    function isLocked(address _wallet) external view returns (bool);
    function getLock(address _wallet) external view returns (uint256);
    function getLocker(address _wallet) external view returns (address);
    function setLock(address _wallet, address _locker, uint256 _releaseAfter) external;
}
// File: contracts/modules/common/IFeature.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
/**
 * @title IFeature
 * @notice Interface for a Feature.
 * @author Julien Niset - <[email protected]>, Olivier VDB - <[email protected]>
 */
interface IFeature {
    enum OwnerSignature {
        Anyone,             // Anyone
        Required,           // Owner required
        Optional,           // Owner and/or guardians
        Disallowed          // guardians only
    }
    /**
    * @notice Utility method to recover any ERC20 token that was sent to the Feature by mistake.
    * @param _token The token to recover.
    */
    function recoverToken(address _token) external;
    /**
     * @notice Inits a Feature for a wallet by e.g. setting some wallet specific parameters in storage.
     * @param _wallet The wallet.
     */
    function init(address _wallet) external;
    /**
     * @notice Helper method to check if an address is an authorised feature of a target wallet.
     * @param _wallet The target wallet.
     * @param _feature The address.
     */
    function isFeatureAuthorisedInVersionManager(address _wallet, address _feature) external view returns (bool);
    /**
    * @notice Gets the number of valid signatures that must be provided to execute a
    * specific relayed transaction.
    * @param _wallet The target wallet.
    * @param _data The data of the relayed transaction.
    * @return The number of required signatures and the wallet owner signature requirement.
    */
    function getRequiredSignatures(address _wallet, bytes calldata _data) external view returns (uint256, OwnerSignature);
    /**
    * @notice Gets the list of static call signatures that this feature responds to on behalf of wallets
    */
    function getStaticCallSignatures() external view returns (bytes4[] memory);
}
// File: lib/other/ERC20.sol
pragma solidity >=0.5.4 <0.7.0;
/**
 * ERC20 contract interface.
 */
interface ERC20 {
    function totalSupply() external view returns (uint);
    function decimals() external view returns (uint);
    function balanceOf(address tokenOwner) external view returns (uint balance);
    function allowance(address tokenOwner, address spender) external view returns (uint remaining);
    function transfer(address to, uint tokens) external returns (bool success);
    function approve(address spender, uint tokens) external returns (bool success);
    function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
// File: contracts/infrastructure/storage/ILimitStorage.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title ILimitStorage
 * @notice LimitStorage interface
 */
interface ILimitStorage {
    struct Limit {
        // the current limit
        uint128 current;
        // the pending limit if any
        uint128 pending;
        // when the pending limit becomes the current limit
        uint64 changeAfter;
    }
    struct DailySpent {
        // The amount already spent during the current period
        uint128 alreadySpent;
        // The end of the current period
        uint64 periodEnd;
    }
    function setLimit(address _wallet, Limit memory _limit) external;
    function getLimit(address _wallet) external view returns (Limit memory _limit);
    function setDailySpent(address _wallet, DailySpent memory _dailySpent) external;
    function getDailySpent(address _wallet) external view returns (DailySpent memory _dailySpent);
    function setLimitAndDailySpent(address _wallet, Limit memory _limit, DailySpent memory _dailySpent) external;
    function getLimitAndDailySpent(address _wallet) external view returns (Limit memory _limit, DailySpent memory _dailySpent);
}
// File: contracts/modules/common/IVersionManager.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
/**
 * @title IVersionManager
 * @notice Interface for the VersionManager module.
 * @author Olivier VDB - <[email protected]>
 */
interface IVersionManager {
    /**
     * @notice Returns true if the feature is authorised for the wallet
     * @param _wallet The target wallet.
     * @param _feature The feature.
     */
    function isFeatureAuthorised(address _wallet, address _feature) external view returns (bool);
    /**
     * @notice Lets a feature (caller) invoke a wallet.
     * @param _wallet The target wallet.
     * @param _to The target address for the transaction.
     * @param _value The value of the transaction.
     * @param _data The data of the transaction.
     */
    function checkAuthorisedFeatureAndInvokeWallet(
        address _wallet,
        address _to,
        uint256 _value,
        bytes calldata _data
    ) external returns (bytes memory _res);
    /* ******* Backward Compatibility with old Storages and BaseWallet *************** */
    /**
     * @notice Sets a new owner for the wallet.
     * @param _newOwner The new owner.
     */
    function setOwner(address _wallet, address _newOwner) external;
    /**
     * @notice Lets a feature write data to a storage contract.
     * @param _wallet The target wallet.
     * @param _storage The storage contract.
     * @param _data The data of the call
     */
    function invokeStorage(address _wallet, address _storage, bytes calldata _data) external;
    /**
     * @notice Upgrade a wallet to a new version.
     * @param _wallet the wallet to upgrade
     * @param _toVersion the new version
     */
    function upgradeWallet(address _wallet, uint256 _toVersion) external;
}
// File: contracts/modules/common/BaseFeature.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.s
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title BaseFeature
 * @notice Base Feature contract that contains methods common to all Feature contracts.
 * @author Julien Niset - <[email protected]>, Olivier VDB - <[email protected]>
 */
contract BaseFeature is IFeature {
    // Empty calldata
    bytes constant internal EMPTY_BYTES = "";
    // Mock token address for ETH
    address constant internal ETH_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    // The address of the Lock storage
    ILockStorage internal lockStorage;
    // The address of the Version Manager
    IVersionManager internal versionManager;
    event FeatureCreated(bytes32 name);
    /**
     * @notice Throws if the wallet is locked.
     */
    modifier onlyWhenUnlocked(address _wallet) {
        require(!lockStorage.isLocked(_wallet), "BF: wallet locked");
        _;
    }
    /**
     * @notice Throws if the sender is not the VersionManager.
     */
    modifier onlyVersionManager() {
        require(msg.sender == address(versionManager), "BF: caller must be VersionManager");
        _;
    }
    /**
     * @notice Throws if the sender is not the owner of the target wallet.
     */
    modifier onlyWalletOwner(address _wallet) {
        require(isOwner(_wallet, msg.sender), "BF: must be wallet owner");
        _;
    }
    /**
     * @notice Throws if the sender is not an authorised feature of the target wallet.
     */
    modifier onlyWalletFeature(address _wallet) {
        require(versionManager.isFeatureAuthorised(_wallet, msg.sender), "BF: must be a wallet feature");
        _;
    }
    /**
     * @notice Throws if the sender is not the owner of the target wallet or the feature itself.
     */
    modifier onlyWalletOwnerOrFeature(address _wallet) {
        // Wrapping in an internal method reduces deployment cost by avoiding duplication of inlined code
        verifyOwnerOrAuthorisedFeature(_wallet, msg.sender);
        _;
    }
    constructor(
        ILockStorage _lockStorage,
        IVersionManager _versionManager,
        bytes32 _name
    ) public {
        lockStorage = _lockStorage;
        versionManager = _versionManager;
        emit FeatureCreated(_name);
    }
    /**
    * @inheritdoc IFeature
    */
    function recoverToken(address _token) external virtual override {
        uint total = ERC20(_token).balanceOf(address(this));
        _token.call(abi.encodeWithSelector(ERC20(_token).transfer.selector, address(versionManager), total));
    }
    /**
     * @notice Inits the feature for a wallet by doing nothing.
     * @dev !! Overriding methods need make sure `init()` can only be called by the VersionManager !!
     * @param _wallet The wallet.
     */
    function init(address _wallet) external virtual override  {}
    /**
     * @inheritdoc IFeature
     */
    function getRequiredSignatures(address, bytes calldata) external virtual view override returns (uint256, OwnerSignature) {
        revert("BF: disabled method");
    }
    /**
     * @inheritdoc IFeature
     */
    function getStaticCallSignatures() external virtual override view returns (bytes4[] memory _sigs) {}
    /**
     * @inheritdoc IFeature
     */
    function isFeatureAuthorisedInVersionManager(address _wallet, address _feature) public override view returns (bool) {
        return versionManager.isFeatureAuthorised(_wallet, _feature);
    }
    /**
    * @notice Checks that the wallet address provided as the first parameter of _data matches _wallet
    * @return false if the addresses are different.
    */
    function verifyData(address _wallet, bytes calldata _data) internal pure returns (bool) {
        require(_data.length >= 36, "RM: Invalid dataWallet");
        address dataWallet = abi.decode(_data[4:], (address));
        return dataWallet == _wallet;
    }
     /**
     * @notice Helper method to check if an address is the owner of a target wallet.
     * @param _wallet The target wallet.
     * @param _addr The address.
     */
    function isOwner(address _wallet, address _addr) internal view returns (bool) {
        return IWallet(_wallet).owner() == _addr;
    }
    /**
     * @notice Verify that the caller is an authorised feature or the wallet owner.
     * @param _wallet The target wallet.
     * @param _sender The caller.
     */
    function verifyOwnerOrAuthorisedFeature(address _wallet, address _sender) internal view {
        require(isFeatureAuthorisedInVersionManager(_wallet, _sender) || isOwner(_wallet, _sender), "BF: must be owner or feature");
    }
    /**
     * @notice Helper method to invoke a wallet.
     * @param _wallet The target wallet.
     * @param _to The target address for the transaction.
     * @param _value The value of the transaction.
     * @param _data The data of the transaction.
     */
    function invokeWallet(address _wallet, address _to, uint256 _value, bytes memory _data)
        internal
        returns (bytes memory _res) 
    {
        _res = versionManager.checkAuthorisedFeatureAndInvokeWallet(_wallet, _to, _value, _data);
    }
}
// File: contracts/modules/common/GuardianUtils.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title GuardianUtils
 * @notice Bundles guardian read logic.
 */
library GuardianUtils {
    /**
    * @notice Checks if an address is a guardian or an account authorised to sign on behalf of a smart-contract guardian
    * given a list of guardians.
    * @param _guardians the list of guardians
    * @param _guardian the address to test
    * @return true and the list of guardians minus the found guardian upon success, false and the original list of guardians if not found.
    */
    function isGuardianOrGuardianSigner(address[] memory _guardians, address _guardian) internal view returns (bool, address[] memory) {
        if (_guardians.length == 0 || _guardian == address(0)) {
            return (false, _guardians);
        }
        bool isFound = false;
        address[] memory updatedGuardians = new address[](_guardians.length - 1);
        uint256 index = 0;
        for (uint256 i = 0; i < _guardians.length; i++) {
            if (!isFound) {
                // check if _guardian is an account guardian
                if (_guardian == _guardians[i]) {
                    isFound = true;
                    continue;
                }
                // check if _guardian is the owner of a smart contract guardian
                if (isContract(_guardians[i]) && isGuardianOwner(_guardians[i], _guardian)) {
                    isFound = true;
                    continue;
                }
            }
            if (index < updatedGuardians.length) {
                updatedGuardians[index] = _guardians[i];
                index++;
            }
        }
        return isFound ? (true, updatedGuardians) : (false, _guardians);
    }
   /**
    * @notice Checks if an address is a contract.
    * @param _addr The address.
    */
    function isContract(address _addr) internal view returns (bool) {
        uint32 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(_addr)
        }
        return (size > 0);
    }
    /**
    * @notice Checks if an address is the owner of a guardian contract.
    * The method does not revert if the call to the owner() method consumes more then 5000 gas.
    * @param _guardian The guardian contract
    * @param _owner The owner to verify.
    */
    function isGuardianOwner(address _guardian, address _owner) internal view returns (bool) {
        address owner = address(0);
        bytes4 sig = bytes4(keccak256("owner()"));
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr,sig)
            let result := staticcall(5000, _guardian, ptr, 0x20, ptr, 0x20)
            if eq(result, 1) {
                owner := mload(ptr)
            }
        }
        return owner == _owner;
    }
}
// File: contracts/infrastructure/ITokenPriceRegistry.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title ITokenPriceRegistry
 * @notice TokenPriceRegistry interface
 */
interface ITokenPriceRegistry {
    function getTokenPrice(address _token) external view returns (uint184 _price);
    function isTokenTradable(address _token) external view returns (bool _isTradable);
}
// File: contracts/modules/common/LimitUtils.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title LimitUtils
 * @notice Helper library to manage the daily limit and interact with a contract implementing the ILimitStorage interface.
 * @author Julien Niset - <[email protected]>
 */
library LimitUtils {
    // large limit when the limit can be considered disabled
    uint128 constant internal LIMIT_DISABLED = uint128(-1);
    using SafeMath for uint256;
    // *************** Internal Functions ********************* //
    /**
     * @notice Changes the daily limit (expressed in ETH).
     * Decreasing the limit is immediate while increasing the limit is pending for the security period.
     * @param _lStorage The storage contract.
     * @param _versionManager The version manager.
     * @param _wallet The target wallet.
     * @param _targetLimit The target limit.
     * @param _securityPeriod The security period.
     */
    function changeLimit(
        ILimitStorage _lStorage,
        IVersionManager _versionManager,
        address _wallet,
        uint256 _targetLimit,
        uint256 _securityPeriod
    )
        internal
        returns (ILimitStorage.Limit memory)
    {
        ILimitStorage.Limit memory limit = _lStorage.getLimit(_wallet);
        uint256 currentLimit = currentLimit(limit);
        ILimitStorage.Limit memory newLimit;
        if (_targetLimit <= currentLimit) {
            uint128 targetLimit = safe128(_targetLimit);
            newLimit = ILimitStorage.Limit(targetLimit, targetLimit, safe64(block.timestamp));
        } else {
            newLimit = ILimitStorage.Limit(safe128(currentLimit), safe128(_targetLimit), safe64(block.timestamp.add(_securityPeriod)));
        }
        setLimit(_versionManager, _lStorage, _wallet, newLimit);
        return newLimit;
    }
     /**
     * @notice Disable the daily limit.
     * The change is pending for the security period.
     * @param _lStorage The storage contract.
     * @param _versionManager The version manager.
     * @param _wallet The target wallet.
     * @param _securityPeriod The security period.
     */
    function disableLimit(
        ILimitStorage _lStorage,
        IVersionManager _versionManager,
        address _wallet,
        uint256 _securityPeriod
    )
        internal
    {
        changeLimit(_lStorage, _versionManager, _wallet, LIMIT_DISABLED, _securityPeriod);
    }
    /**
    * @notice Returns whether the daily limit is disabled for a wallet.
    * @param _wallet The target wallet.
    * @return _limitDisabled true if the daily limit is disabled, false otherwise.
    */
    function isLimitDisabled(ILimitStorage _lStorage, address _wallet) internal view returns (bool) {
        ILimitStorage.Limit memory limit = _lStorage.getLimit(_wallet);
        uint256 currentLimit = currentLimit(limit);
        return (currentLimit == LIMIT_DISABLED);
    }
    /**
    * @notice Checks if a transfer is within the limit. If yes the daily spent is updated.
    * @param _lStorage The storage contract.
    * @param _versionManager The Version Manager.
    * @param _wallet The target wallet.
    * @param _amount The amount for the transfer
    * @return true if the transfer is withing the daily limit.
    */
    function checkAndUpdateDailySpent(
        ILimitStorage _lStorage,
        IVersionManager _versionManager,
        address _wallet,
        uint256 _amount
    )
        internal
        returns (bool)
    {
        (ILimitStorage.Limit memory limit, ILimitStorage.DailySpent memory dailySpent) = _lStorage.getLimitAndDailySpent(_wallet);
        uint256 currentLimit = currentLimit(limit);
        if (_amount == 0 || currentLimit == LIMIT_DISABLED) {
            return true;
        }
        ILimitStorage.DailySpent memory newDailySpent;
        if (dailySpent.periodEnd <= block.timestamp && _amount <= currentLimit) {
            newDailySpent = ILimitStorage.DailySpent(safe128(_amount), safe64(block.timestamp + 24 hours));
            setDailySpent(_versionManager, _lStorage, _wallet, newDailySpent);
            return true;
        } else if (dailySpent.periodEnd > block.timestamp && _amount.add(dailySpent.alreadySpent) <= currentLimit) {
            newDailySpent = ILimitStorage.DailySpent(safe128(_amount.add(dailySpent.alreadySpent)), safe64(dailySpent.periodEnd));
            setDailySpent(_versionManager, _lStorage, _wallet, newDailySpent);
            return true;
        }
        return false;
    }
    /**
    * @notice Helper method to Reset the daily consumption.
    * @param _versionManager The Version Manager.
    * @param _wallet The target wallet.
    */
    function resetDailySpent(IVersionManager _versionManager, ILimitStorage limitStorage, address _wallet) internal {
        setDailySpent(_versionManager, limitStorage, _wallet, ILimitStorage.DailySpent(uint128(0), uint64(0)));
    }
    /**
    * @notice Helper method to get the ether value equivalent of a token amount.
    * @notice For low value amounts of tokens we accept this to return zero as these are small enough to disregard.
    * Note that the price stored for tokens = price for 1 token (in ETH wei) * 10^(18-token decimals).
    * @param _amount The token amount.
    * @param _token The address of the token.
    * @return The ether value for _amount of _token.
    */
    function getEtherValue(ITokenPriceRegistry _priceRegistry, uint256 _amount, address _token) internal view returns (uint256) {
        uint256 price = _priceRegistry.getTokenPrice(_token);
        uint256 etherValue = price.mul(_amount).div(10**18);
        return etherValue;
    }
    /**
    * @notice Helper method to get the current limit from a Limit struct.
    * @param _limit The limit struct
    */
    function currentLimit(ILimitStorage.Limit memory _limit) internal view returns (uint256) {
        if (_limit.changeAfter > 0 && _limit.changeAfter < block.timestamp) {
            return _limit.pending;
        }
        return _limit.current;
    }
    function safe128(uint256 _num) internal pure returns (uint128) {
        require(_num < 2**128, "LU: more then 128 bits");
        return uint128(_num);
    }
    function safe64(uint256 _num) internal pure returns (uint64) {
        require(_num < 2**64, "LU: more then 64 bits");
        return uint64(_num);
    }
    // *************** Storage invocations in VersionManager ********************* //
    function setLimit(
        IVersionManager _versionManager,
        ILimitStorage _lStorage,
        address _wallet, 
        ILimitStorage.Limit memory _limit
    ) internal {
        _versionManager.invokeStorage(
            _wallet,
            address(_lStorage),
            abi.encodeWithSelector(_lStorage.setLimit.selector, _wallet, _limit)
        );
    }
    function setDailySpent(
        IVersionManager _versionManager,
        ILimitStorage _lStorage,
        address _wallet, 
        ILimitStorage.DailySpent memory _dailySpent
    ) private {
        _versionManager.invokeStorage(
            _wallet,
            address(_lStorage),
            abi.encodeWithSelector(_lStorage.setDailySpent.selector, _wallet, _dailySpent)
        );
    }
}
// File: contracts/infrastructure/storage/IGuardianStorage.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
pragma solidity >=0.5.4 <0.7.0;
interface IGuardianStorage {
    /**
     * @notice Lets an authorised module add a guardian to a wallet.
     * @param _wallet The target wallet.
     * @param _guardian The guardian to add.
     */
    function addGuardian(address _wallet, address _guardian) external;
    /**
     * @notice Lets an authorised module revoke a guardian from a wallet.
     * @param _wallet The target wallet.
     * @param _guardian The guardian to revoke.
     */
    function revokeGuardian(address _wallet, address _guardian) external;
    /**
     * @notice Checks if an account is a guardian for a wallet.
     * @param _wallet The target wallet.
     * @param _guardian The account.
     * @return true if the account is a guardian for a wallet.
     */
    function isGuardian(address _wallet, address _guardian) external view returns (bool);
    function isLocked(address _wallet) external view returns (bool);
    function getLock(address _wallet) external view returns (uint256);
    function getLocker(address _wallet) external view returns (address);
    function setLock(address _wallet, uint256 _releaseAfter) external;
    function getGuardians(address _wallet) external view returns (address[] memory);
    function guardianCount(address _wallet) external view returns (uint256);
}
// File: modules/RelayerManager.sol
// Copyright (C) 2018  Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
/**
 * @title RelayerManager
 * @notice Feature to execute transactions signed by ETH-less accounts and sent by a relayer.
 * @author Julien Niset <[email protected]>, Olivier VDB <[email protected]>
 */
contract RelayerManager is BaseFeature {
    bytes32 constant NAME = "RelayerManager";
    uint256 constant internal BLOCKBOUND = 10000;
    using SafeMath for uint256;
    mapping (address => RelayerConfig) public relayer;
    // The storage of the limit
    ILimitStorage public limitStorage;
    // The Token price storage
    ITokenPriceRegistry public tokenPriceRegistry;
    // The Guardian storage
    IGuardianStorage public guardianStorage;
    struct RelayerConfig {
        uint256 nonce;
        mapping (bytes32 => bool) executedTx;
    }
    // Used to avoid stack too deep error
    struct StackExtension {
        uint256 requiredSignatures;
        OwnerSignature ownerSignatureRequirement;
        bytes32 signHash;
        bool success;
        bytes returnData;
    }
    event TransactionExecuted(address indexed wallet, bool indexed success, bytes returnData, bytes32 signedHash);
    event Refund(address indexed wallet, address indexed refundAddress, address refundToken, uint256 refundAmount);
    /* ***************** External methods ************************* */
    constructor(
        ILockStorage _lockStorage,
        IGuardianStorage _guardianStorage,
        ILimitStorage _limitStorage,
        ITokenPriceRegistry _tokenPriceRegistry,
        IVersionManager _versionManager
    )
        BaseFeature(_lockStorage, _versionManager, NAME)
        public
    {
        limitStorage = _limitStorage;
        tokenPriceRegistry = _tokenPriceRegistry;
        guardianStorage = _guardianStorage;
    }
    /**
    * @notice Executes a relayed transaction.
    * @param _wallet The target wallet.
    * @param _feature The target feature.
    * @param _data The data for the relayed transaction
    * @param _nonce The nonce used to prevent replay attacks.
    * @param _signatures The signatures as a concatenated byte array.
    * @param _gasPrice The gas price to use for the gas refund.
    * @param _gasLimit The gas limit to use for the gas refund.
    * @param _refundToken The token to use for the gas refund.
    * @param _refundAddress The address refunded to prevent front-running.
    */
    function execute(
        address _wallet,
        address _feature,
        bytes calldata _data,
        uint256 _nonce,
        bytes calldata _signatures,
        uint256 _gasPrice,
        uint256 _gasLimit,
        address _refundToken,
        address _refundAddress
    )
        external
        returns (bool)
    {
        uint startGas = gasleft();
        require(startGas >= _gasLimit, "RM: not enough gas provided");
        require(verifyData(_wallet, _data), "RM: Target of _data != _wallet");
        require(isFeatureAuthorisedInVersionManager(_wallet, _feature), "RM: feature not authorised");
        StackExtension memory stack;
        (stack.requiredSignatures, stack.ownerSignatureRequirement) = IFeature(_feature).getRequiredSignatures(_wallet, _data);
        require(stack.requiredSignatures > 0 || stack.ownerSignatureRequirement == OwnerSignature.Anyone, "RM: Wrong signature requirement");
        require(stack.requiredSignatures * 65 == _signatures.length, "RM: Wrong number of signatures");
        stack.signHash = getSignHash(
            address(this),
            _feature,
            0,
            _data,
            _nonce,
            _gasPrice,
            _gasLimit,
            _refundToken,
            _refundAddress);
        require(checkAndUpdateUniqueness(
            _wallet,
            _nonce,
            stack.signHash,
            stack.requiredSignatures,
            stack.ownerSignatureRequirement), "RM: Duplicate request");
        require(validateSignatures(_wallet, stack.signHash, _signatures, stack.ownerSignatureRequirement), "RM: Invalid signatures");
        (stack.success, stack.returnData) = _feature.call(_data);
        // only refund when approved by owner and positive gas price
        if (_gasPrice > 0 && stack.ownerSignatureRequirement == OwnerSignature.Required) {
            refund(
                _wallet,
                startGas,
                _gasPrice,
                _gasLimit,
                _refundToken,
                _refundAddress,
                stack.requiredSignatures);
        }
        emit TransactionExecuted(_wallet, stack.success, stack.returnData, stack.signHash);
        return stack.success;
    }
    /**
    * @notice Gets the current nonce for a wallet.
    * @param _wallet The target wallet.
    */
    function getNonce(address _wallet) external view returns (uint256 nonce) {
        return relayer[_wallet].nonce;
    }
    /**
    * @notice Checks if a transaction identified by its sign hash has already been executed.
    * @param _wallet The target wallet.
    * @param _signHash The sign hash of the transaction.
    */
    function isExecutedTx(address _wallet, bytes32 _signHash) external view returns (bool executed) {
        return relayer[_wallet].executedTx[_signHash];
    }
    /* ***************** Internal & Private methods ************************* */
    /**
    * @notice Generates the signed hash of a relayed transaction according to ERC 1077.
    * @param _from The starting address for the relayed transaction (should be the relayer module)
    * @param _to The destination address for the relayed transaction (should be the target module)
    * @param _value The value for the relayed transaction.
    * @param _data The data for the relayed transaction which includes the wallet address.
    * @param _nonce The nonce used to prevent replay attacks.
    * @param _gasPrice The gas price to use for the gas refund.
    * @param _gasLimit The gas limit to use for the gas refund.
    * @param _refundToken The token to use for the gas refund.
    * @param _refundAddress The address refunded to prevent front-running.
    */
    function getSignHash(
        address _from,
        address _to,
        uint256 _value,
        bytes memory _data,
        uint256 _nonce,
        uint256 _gasPrice,
        uint256 _gasLimit,
        address _refundToken,
        address _refundAddress
    )
        internal
        pure
        returns (bytes32)
    {
        return keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                keccak256(abi.encodePacked(
                    byte(0x19),
                    byte(0),
                    _from,
                    _to,
                    _value,
                    _data,
                    getChainId(),
                    _nonce,
                    _gasPrice,
                    _gasLimit,
                    _refundToken,
                    _refundAddress))
        ));
    }
    /**
    * @notice Checks if the relayed transaction is unique. If yes the state is updated.
    * For actions requiring 1 signature by the owner we use the incremental nonce.
    * For all other actions we check/store the signHash in a mapping.
    * @param _wallet The target wallet.
    * @param _nonce The nonce.
    * @param _signHash The signed hash of the transaction.
    * @param requiredSignatures The number of signatures required.
    * @param ownerSignatureRequirement The wallet owner signature requirement.
    * @return true if the transaction is unique.
    */
    function checkAndUpdateUniqueness(
        address _wallet,
        uint256 _nonce,
        bytes32 _signHash,
        uint256 requiredSignatures,
        OwnerSignature ownerSignatureRequirement
    )
        internal
        returns (bool)
    {
        if (requiredSignatures == 1 && ownerSignatureRequirement == OwnerSignature.Required) {
            // use the incremental nonce
            if (_nonce <= relayer[_wallet].nonce) {
                return false;
            }
            uint256 nonceBlock = (_nonce & 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000) >> 128;
            if (nonceBlock > block.number + BLOCKBOUND) {
                return false;
            }
            relayer[_wallet].nonce = _nonce;
            return true;
        } else {
            // use the txHash map
            if (relayer[_wallet].executedTx[_signHash] == true) {
                return false;
            }
            relayer[_wallet].executedTx[_signHash] = true;
            return true;
        }
    }
    /**
    * @notice Validates the signatures provided with a relayed transaction.
    * The method MUST throw if one or more signatures are not valid.
    * @param _wallet The target wallet.
    * @param _signHash The signed hash representing the relayed transaction.
    * @param _signatures The signatures as a concatenated byte array.
    * @param _option An enum indicating whether the owner is required, optional or disallowed.
    * @return A boolean indicating whether the signatures are valid.
    */
    function validateSignatures(
        address _wallet,
        bytes32 _signHash,
        bytes memory _signatures,
        OwnerSignature _option
    )
        internal
        view
        returns (bool)
    {
        if (_signatures.length == 0) {
            return true;
        }
        address lastSigner = address(0);
        address[] memory guardians;
        if (_option != OwnerSignature.Required || _signatures.length > 65) {
            guardians = guardianStorage.getGuardians(_wallet); // guardians are only read if they may be needed
        }
        bool isGuardian;
        for (uint256 i = 0; i < _signatures.length / 65; i++) {
            address signer = Utils.recoverSigner(_signHash, _signatures, i);
            if (i == 0) {
                if (_option == OwnerSignature.Required) {
                    // First signer must be owner
                    if (isOwner(_wallet, signer)) {
                        continue;
                    }
                    return false;
                } else if (_option == OwnerSignature.Optional) {
                    // First signer can be owner
                    if (isOwner(_wallet, signer)) {
                        continue;
                    }
                }
            }
            if (signer <= lastSigner) {
                return false; // Signers must be different
            }
            lastSigner = signer;
            (isGuardian, guardians) = GuardianUtils.isGuardianOrGuardianSigner(guardians, signer);
            if (!isGuardian) {
                return false;
            }
        }
        return true;
    }
    /**
    * @notice Refunds the gas used to the Relayer.
    * @param _wallet The target wallet.
    * @param _startGas The gas provided at the start of the execution.
    * @param _gasPrice The gas price for the refund.
    * @param _gasLimit The gas limit for the refund.
    * @param _refundToken The token to use for the gas refund.
    * @param _refundAddress The address refunded to prevent front-running.
    * @param _requiredSignatures The number of signatures required.
    */
    function refund(
        address _wallet,
        uint _startGas,
        uint _gasPrice,
        uint _gasLimit,
        address _refundToken,
        address _refundAddress,
        uint256 _requiredSignatures
    )
        internal
    {
        address refundAddress = _refundAddress == address(0) ? msg.sender : _refundAddress;
        uint256 refundAmount;
        // skip daily limit when approved by guardians (and signed by owner)
        if (_requiredSignatures > 1) {
            uint256 gasConsumed = _startGas.sub(gasleft()).add(30000);
            refundAmount = Utils.min(gasConsumed, _gasLimit).mul(_gasPrice);
        } else {
            uint256 gasConsumed = _startGas.sub(gasleft()).add(40000);
            refundAmount = Utils.min(gasConsumed, _gasLimit).mul(_gasPrice);
            uint256 ethAmount = (_refundToken == ETH_TOKEN) ? refundAmount : LimitUtils.getEtherValue(tokenPriceRegistry, refundAmount, _refundToken);
            require(LimitUtils.checkAndUpdateDailySpent(limitStorage, versionManager, _wallet, ethAmount), "RM: refund is above daily limit");
        }
        // refund in ETH or ERC20
        if (_refundToken == ETH_TOKEN) {
            invokeWallet(_wallet, refundAddress, refundAmount, EMPTY_BYTES);
        } else {
            bytes memory methodData = abi.encodeWithSignature("transfer(address,uint256)", refundAddress, refundAmount);
		    bytes memory transferSuccessBytes = invokeWallet(_wallet, _refundToken, 0, methodData);
            // Check token refund is successful, when `transfer` returns a success bool result
            if (transferSuccessBytes.length > 0) {
                require(abi.decode(transferSuccessBytes, (bool)), "RM: Refund transfer failed");
            }
        }
        emit Refund(_wallet, refundAddress, _refundToken, refundAmount);
    }
   /**
    * @notice Returns the current chainId
    * @return chainId the chainId
    */
    function getChainId() private pure returns (uint256 chainId) {
        // solhint-disable-next-line no-inline-assembly
        assembly { chainId := chainid() }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ILockStorage","name":"_lockStorage","type":"address"},{"internalType":"contract IGuardianStorage","name":"_guardianStorage","type":"address"},{"internalType":"contract ILimitStorage","name":"_limitStorage","type":"address"},{"internalType":"contract ITokenPriceRegistry","name":"_tokenPriceRegistry","type":"address"},{"internalType":"contract IVersionManager","name":"_versionManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"FeatureCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":true,"internalType":"address","name":"refundAddress","type":"address"},{"indexed":false,"internalType":"address","name":"refundToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"refundAmount","type":"uint256"}],"name":"Refund","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":true,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"bytes","name":"returnData","type":"bytes"},{"indexed":false,"internalType":"bytes32","name":"signedHash","type":"bytes32"}],"name":"TransactionExecuted","type":"event"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"},{"internalType":"address","name":"_feature","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"bytes","name":"_signatures","type":"bytes"},{"internalType":"uint256","name":"_gasPrice","type":"uint256"},{"internalType":"uint256","name":"_gasLimit","type":"uint256"},{"internalType":"address","name":"_refundToken","type":"address"},{"internalType":"address","name":"_refundAddress","type":"address"}],"name":"execute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"getRequiredSignatures","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"enum IFeature.OwnerSignature","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStaticCallSignatures","outputs":[{"internalType":"bytes4[]","name":"_sigs","type":"bytes4[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guardianStorage","outputs":[{"internalType":"contract IGuardianStorage","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"},{"internalType":"bytes32","name":"_signHash","type":"bytes32"}],"name":"isExecutedTx","outputs":[{"internalType":"bool","name":"executed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"},{"internalType":"address","name":"_feature","type":"address"}],"name":"isFeatureAuthorisedInVersionManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitStorage","outputs":[{"internalType":"contract ILimitStorage","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"recoverToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"relayer","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPriceRegistry","outputs":[{"internalType":"contract ITokenPriceRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

42850:13314:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43116:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24679:60;;;;;;:::i;:::-;;:::i;:::-;;47420:121;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;24792:169::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;47757:160::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;24207:245::-;;;;;;:::i;:::-;;:::i;25167:195::-;;;;;;:::i;:::-;;:::i;45036:2268::-;;;;;;:::i;:::-;;:::i;43027:49::-;;;;;;:::i;:::-;;:::i;43188:45::-;;;:::i;43269:39::-;;;:::i;25014:100::-;;;:::i;:::-;;;;;;;:::i;43116:33::-;;;-1:-1:-1;;;;;43116:33:0;;:::o;24679:60::-;;:::o;47420:121::-;-1:-1:-1;;;;;47511:16:0;;47478:13;47511:16;;;:7;:16;;;;;:22;47420:121;;;;:::o;24792:169::-;24888:7;24897:14;24924:29;;-1:-1:-1;;;24924:29:0;;;;;;;:::i;:::-;;;;;;;;47757:160;-1:-1:-1;;;;;47871:16:0;;47838:13;47871:16;;;:7;:16;;;;;;;;:38;;;:27;;:38;;;;;;;;47757:160;;;;;:::o;24207:245::-;24295:38;;;;;24282:10;;-1:-1:-1;;;;;24295:23:0;;;;;:38;;24327:4;;24295:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24420:14;;24356:87;;24282:51;;-1:-1:-1;;;;;;24344:11:0;;;;-1:-1:-1;;;24379:31:0;24356:87;;24420:14;;24282:51;;24356:87;;;:::i;:::-;;;;-1:-1:-1;;24356:87:0;;;;;;;;;;;;;;-1:-1:-1;;;;;24356:87:0;;;;;;;;;;;;24344:100;;;;24356:87;24344:100;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24207:245;;:::o;25167:195::-;25301:14;;:53;;;;;25277:4;;-1:-1:-1;;;;;25301:14:0;;:34;;:53;;25336:7;;25345:8;;25301:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25294:60;25167:195;-1:-1:-1;;;25167:195:0:o;45036:2268::-;45362:4;45384:13;45400:9;45384:25;;45440:9;45428:8;:21;;45420:61;;;;-1:-1:-1;;;45420:61:0;;;;;;;:::i;:::-;45500:26;45511:7;45520:5;;45500:10;:26::i;:::-;45492:69;;;;-1:-1:-1;;;45492:69:0;;;;;;;:::i;:::-;45580:54;45616:7;45625:8;45580:35;:54::i;:::-;45572:93;;;;-1:-1:-1;;;45572:93:0;;;;;;;:::i;:::-;45676:27;;:::i;:::-;45785:8;-1:-1:-1;;;;;45776:40:0;;45817:7;45826:5;;45776:56;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45715:5;45741:31;;;45714:118;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45851:24:0;;:28;;;:88;;-1:-1:-1;45918:21:0;45883:5;:31;;;:56;;;;;;;;;45851:88;45843:132;;;;-1:-1:-1;;;45843:132:0;;;;;;;:::i;:::-;45994:24;;46021:2;45994:29;:51;;45986:94;;;;-1:-1:-1;;;45986:94:0;;;;;;;:::i;:::-;46108:224;46142:4;46162:8;46185:1;46201:5;;46108:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46221:6;46242:9;46266;46290:12;46317:14;46108:11;:224::i;:::-;46091:5;:14;;:241;;;;;46351:182;46390:7;46412:6;46433:5;:14;;;46462:5;:24;;;46501:5;:31;;;46351:24;:182::i;:::-;46343:216;;;;-1:-1:-1;;;46343:216:0;;;;;;;:::i;:::-;46578:89;46597:7;46606:5;:14;;;46622:11;;46578:89;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;46635:31:0;;;;46578:18;:89::i;:::-;46570:124;;;;-1:-1:-1;;;46570:124:0;;;;;;;:::i;:::-;46741:8;-1:-1:-1;;;;;46741:13:0;46755:5;;46741:20;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46721:16:0;;;46705:56;;;46706:13;;;46705:56;46846:13;;;;;:75;;-1:-1:-1;46898:23:0;46863:5;:31;;;:58;;;;;;;;;46846:75;46842:331;;;46938:223;46963:7;46989:8;47016:9;47044;47072:12;47103:14;47136:5;:24;;;46938:6;:223::i;:::-;47217:5;:13;;;47188:77;;47208:7;-1:-1:-1;;;;;47188:77:0;;47232:5;:16;;;47250:5;:14;;;47188:77;;;;;;;:::i;:::-;;;;;;;;47283:13;;;;45036:2268;-1:-1:-1;;;;;;;;;;;;;45036:2268:0:o;43027:49::-;;;;;;;;;;;;;:::o;43188:45::-;;;-1:-1:-1;;;;;43188:45:0;;:::o;43269:39::-;;;-1:-1:-1;;;;;43269:39:0;;:::o;25014:100::-;25089:21;25014:100;:::o;25541:263::-;25623:4;25664:2;25648:18;;;25640:53;;;;-1:-1:-1;;;25640:53:0;;;;;;;:::i;:::-;25704:18;25736:9;:5;25742:1;25736:5;;:9;:::i;:::-;25725:32;;;;;;;:::i;:::-;-1:-1:-1;;;;;25775:21:0;;;;;;;;-1:-1:-1;;25541:263:0;;;;;:::o;48796:889::-;49119:7;49312:10;49119:7;49375:5;49403:3;49429:6;49458:5;49486:12;:10;:12::i;:::-;49521:6;49550:9;49582;49614:12;49649:14;49273:391;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49263:402;;;;;;49175:501;;;;;;;;:::i;:::-;;;;;;;;;;;;;49151:526;;;;;;49144:533;;48796:889;;;;;;;;;;;:::o;50283:1060::-;50527:4;50553:18;50575:1;50553:23;:79;;;;-1:-1:-1;50609:23:0;50580:25;:52;;;;;;;;;50553:79;50549:787;;;-1:-1:-1;;;;;50705:16:0;;;;;;:7;:16;;;;;:22;50695:32;;50691:85;;-1:-1:-1;50755:5:0;50748:12;;50691:85;50892:3;50811:84;;;50927:12;42982:5;50927:25;50914:38;;50910:91;;;50980:5;50973:12;;;;;50910:91;-1:-1:-1;;;;;;;51015:16:0;;;;;;:7;:16;;;;;:31;;;51068:4;51061:11;;50549:787;-1:-1:-1;;;;;51144:16:0;;;;;;:7;:16;;;;;;;;:38;;;:27;;;;:38;;;;;;;;;:46;;;51140:99;;;-1:-1:-1;51218:5:0;51211:12;;51140:99;-1:-1:-1;;;;;;51253:16:0;;;;;;:7;:16;;;;;;;;:38;;;51294:4;51253:27;;;:38;;;;;;:45;;-1:-1:-1;;51253:45:0;;;;;50549:787;50283:1060;;;;;;;:::o;51869:1658::-;52076:4;52102:11;:18;52124:1;52102:23;52098:67;;;-1:-1:-1;52149:4:0;52142:11;;52098:67;52175:18;52217:26;52269:23;52258:7;:34;;;;;;;;;;:61;;;;52317:2;52296:11;:18;:23;52258:61;52254:192;;;52348:15;;:37;;;;;-1:-1:-1;;;;;52348:15:0;;;;:28;;:37;;52377:7;;52348:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52348:37:0;;;;;;;;;;;;:::i;:::-;52336:49;;52254:192;52456:15;;52482:1016;52527:2;52506:11;:18;:23;;;;;;52502:1;:27;52482:1016;;;52551:14;52568:46;52588:9;52599:11;52612:1;52568:19;:46::i;:::-;52551:63;-1:-1:-1;52633:6:0;52629:530;;52675:23;52664:7;:34;;;;;;;;;52660:484;;;52778:24;52786:7;52795:6;52778:7;:24::i;:::-;52774:89;;;52831:8;;;52774:89;52892:5;52885:12;;;;;;;;;52660:484;52938:23;52927:7;:34;;;;;;;;;52923:221;;;53040:24;53048:7;53057:6;53040:7;:24::i;:::-;53036:89;;;53093:8;;;53036:89;53187:10;-1:-1:-1;;;;;53177:20:0;:6;-1:-1:-1;;;;;53177:20:0;;53173:102;;53225:5;53218:12;;;;;;;;;53173:102;53302:6;53289:19;;53349:59;53390:9;53401:6;53349:40;:59::i;:::-;53323:85;-1:-1:-1;53323:85:0;-1:-1:-1;53323:85:0;53423:64;;53466:5;53459:12;;;;;;;;;53423:64;52482:1016;;52531:3;;52482:1016;;;;53515:4;53508:11;;;;;51869:1658;;;;;;;:::o;54032:1860::-;54292:21;-1:-1:-1;;;;;54316:28:0;;;:58;;54360:14;54316:58;;;54347:10;54316:58;54292:82;;54385:20;54520:1;54498:19;:23;54494:655;;;54538:19;54560:35;54589:5;54560:24;54574:9;54560;;:13;:24::i;:::-;:28;;:35::i;:::-;54538:57;;54625:48;54663:9;54625:33;54635:11;54648:9;54625;:33::i;:::-;:37;;:48::i;:::-;54610:63;;54494:655;;;;54706:19;54728:35;54757:5;54728:24;54742:9;54728;;:13;:24::i;:35::-;54706:57;;54793:48;54831:9;54793:33;54803:11;54816:9;54793;:33::i;:48::-;54778:63;-1:-1:-1;54856:17:0;-1:-1:-1;;;;;54877:25:0;;22323:42;54877:25;54876:117;;54946:18;;54921:72;;-1:-1:-1;;;;;54946:18:0;54966:12;54980;54921:24;:72::i;:::-;54876:117;;;54906:12;54876:117;55052:12;;;55066:14;54856:137;;-1:-1:-1;55016:85:0;;-1:-1:-1;;;;;55052:12:0;;;;55066:14;55082:7;54856:137;55016:35;:85::i;:::-;55008:129;;;;-1:-1:-1;;;55008:129:0;;;;;;;:::i;:::-;54494:655;;;-1:-1:-1;;;;;55198:25:0;;22323:42;55198:25;55194:617;;;55240:63;55253:7;55262:13;55277:12;55291:11;;;;;;;;;;;;55240:12;:63::i;:::-;;55194:617;;;55336:23;55415:13;55430:12;55362:81;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;55362:81:0;;;;;;;;;;;;;;-1:-1:-1;;;;;55362:81:0;-1:-1:-1;;;55362:81:0;;;;-1:-1:-1;55452:33:0;55488:50;55501:7;55510:12;-1:-1:-1;55362:81:0;55488:12;:50::i;:::-;55653:27;;55452:86;;-1:-1:-1;55653:31:0;55649:151;;55724:20;55713:40;;;;;;;;;;;;:::i;:::-;55705:79;;;;-1:-1:-1;;;55705:79:0;;;;;;;:::i;:::-;55194:617;;;55842:13;-1:-1:-1;;;;;55826:58:0;55833:7;-1:-1:-1;;;;;55826:58:0;;55857:12;55871;55826:58;;;;;;;:::i;:::-;;;;;;;;54032:1860;;;;;;;;;:::o;55992:169::-;56143:9;;56130:24::o;1219:927::-;1740:4;1736:16;;;1710:44;;1731:4;1710:44;;1704:51;1801:4;1780:44;;1774:51;1854:44;;;;1848:51;1325:7;;1901:4;1844:62;;;;;1940:2;1935:7;;;:18;;;1946:1;:7;;1951:2;1946:7;1935:18;1927:27;;;;;;1965:24;1992:31;2002:11;2015:1;2018;2021;1992:31;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1992:31:0;;-1:-1:-1;;1992:31:0;;;-1:-1:-1;;;;;;;2042:30:0;;2034:70;;;;-1:-1:-1;;;2034:70:0;;;;;;;:::i;:::-;2122:16;1219:927;-1:-1:-1;;;;;;;1219:927:0:o;25991:137::-;26063:4;26115:5;-1:-1:-1;;;;;26087:33:0;26095:7;-1:-1:-1;;;;;26087:22:0;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26087:33:0;;;25991:137;-1:-1:-1;;;25991:137:0:o;28359:1201::-;28466:4;28472:16;28505:10;:17;28526:1;28505:22;:49;;;-1:-1:-1;;;;;;28531:23:0;;;28505:49;28501:108;;;-1:-1:-1;28579:5:0;;-1:-1:-1;28586:10:0;28571:26;;28501:108;28619:12;28650:33;28720:1;28700:10;:17;:21;28686:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28686:36:0;;28650:72;;28733:13;28766:9;28761:718;28785:10;:17;28781:1;:21;28761:718;;;28829:7;28824:493;;28936:10;28947:1;28936:13;;;;;;;;;;;;;;-1:-1:-1;;;;;28923:26:0;:9;-1:-1:-1;;;;;28923:26:0;;28919:120;;;28984:4;28974:14;;29011:8;;28919:120;29142:25;29153:10;29164:1;29153:13;;;;;;;;;;;;;;29142:10;:25::i;:::-;:70;;;;;29171:41;29187:10;29198:1;29187:13;;;;;;;;;;;;;;29202:9;29171:15;:41::i;:::-;29138:164;;;29247:4;29237:14;;29274:8;;29138:164;29343:16;:23;29335:5;:31;29331:137;;;29413:10;29424:1;29413:13;;;;;;;;;;;;;;29387:16;29404:5;29387:23;;;;;;;;-1:-1:-1;;;;;29387:39:0;;;:23;;;;;;;;;;;:39;29445:7;;;;;29331:137;28804:3;;28761:718;;;;29496:7;:56;;29534:5;29541:10;29496:56;;;29507:4;29513:16;29496:56;29489:63;;;;;;;28359:1201;;;;;;:::o;4304:136::-;4362:7;4389:43;4393:1;4396;4389:43;;;;;;;;;;;;;;;;;:3;:43::i;3852:179::-;3910:7;3942:5;;;3966:6;;;;3958:46;;;;-1:-1:-1;;;3958:46:0;;;;;;;:::i;2813:150::-;2871:7;2899:1;2895;:5;2891:46;;;-1:-1:-1;2924:1:0;2917:8;;2891:46;-1:-1:-1;2954:1:0;2813:150;-1:-1:-1;2813:150:0:o;5172:467::-;5230:7;5475:6;5471:47;;-1:-1:-1;5505:1:0;5498:8;;5471:47;5540:5;;;5544:1;5540;:5;:1;5564:5;;;;;:10;5556:56;;;;-1:-1:-1;;;5556:56:0;;;;;;;:::i;37877:285::-;37992:7;38012:13;38028:14;-1:-1:-1;;;;;38028:28:0;;38057:6;38028:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38012:52;;;-1:-1:-1;38075:18:0;38096:30;38119:6;38096:18;38012:52;38106:7;38096:9;:18::i;:::-;:22;;:30::i;:::-;38075:51;37877:285;-1:-1:-1;;;;;;37877:285:0:o;35748:1253::-;35953:4;35976:32;;:::i;:::-;36010:42;;:::i;:::-;36056:40;;;;;-1:-1:-1;;;;;36056:31:0;;;;;:40;;36088:7;;36056:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;35975:121;;;;36107:20;36130:19;36143:5;36130:12;:19::i;:::-;36107:42;-1:-1:-1;36164:12:0;;;:46;;-1:-1:-1;;;;;;36180:30:0;;36164:46;36160:90;;;36234:4;36227:11;;;;;;;36160:90;36260:45;;:::i;:::-;36344:15;36320:10;:20;;;:39;;;;:66;;;;;36374:12;36363:7;:23;;36320:66;36316:655;;;36419:78;;;;;;;;36444:16;36452:7;36444;:16::i;:::-;-1:-1:-1;;;;;36419:78:0;;;;;36462:34;36469:15;36487:8;36469:26;36462:6;:34::i;:::-;36419:78;;;;36403:94;-1:-1:-1;36512:65:0;36526:15;36543:9;36554:7;36403:94;36512:13;:65::i;:::-;36599:4;36592:11;;;;;;;;36316:655;36648:15;36625:10;:20;;;:38;;;:94;;;;-1:-1:-1;36679:23:0;;36707:12;;36667:36;;:7;;-1:-1:-1;;;;;36667:36:0;:11;:36::i;:::-;:52;;36625:94;36621:350;;;36752:101;;;;;;;;36777:45;36785:36;36797:10;:23;;;-1:-1:-1;;;;;36785:36:0;:7;:11;;:36;;;;:::i;:::-;36777:7;:45::i;:::-;-1:-1:-1;;;;;36752:101:0;;;;;36824:28;36831:10;:20;;;36824:28;;:6;:28::i;36621:350::-;-1:-1:-1;36988:5:0;;35748:1253;-1:-1:-1;;;;;;;;35748:1253:0:o;26821:256::-;26988:14;;:81;;;;;26945:17;;-1:-1:-1;;;;;26988:14:0;;:52;;:81;;27041:7;;27050:3;;27055:6;;27063:5;;26988:81;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;26988:81:0;;;;;;;;;;;;:::i;29666:250::-;29852:18;29899:8;;;;;29666:250::o;30197:533::-;30484:4;30478:11;30354:20;30503:15;;;30280:4;;;;30354:20;30590:4;30478:11;30590:4;30478:11;30563:9;30557:4;30546:49;30623:1;30615:6;30612:13;30609:2;;;30660:3;30654:10;30645:19;;30609:2;;;30716:6;-1:-1:-1;;;;;30707:15:0;:5;-1:-1:-1;;;;;30707:15:0;;30700:22;;;;30197:533;;;;:::o;4733:190::-;4819:7;4855:12;4847:6;;;;4839:29;;;;-1:-1:-1;;;4839:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;4891:5:0;;;4733:190::o;6105:132::-;6163:7;6190:39;6194:1;6197;6190:39;;;;;;;;;;;;;;;;;:3;:39::i;38298:255::-;38378:7;38423:1;38402:6;:18;;;:22;;;:62;;;;;38449:15;38428:6;:18;;;:36;;;38402:62;38398:116;;;-1:-1:-1;38488:14:0;;;;-1:-1:-1;;;;;38481:21:0;;;38398:116;-1:-1:-1;38531:14:0;-1:-1:-1;;;;;38524:21:0;;38298:255::o;38559:161::-;38613:7;38648:6;38641:4;:13;38633:48;;;;-1:-1:-1;;;38633:48:0;;;;;;;:::i;:::-;-1:-1:-1;38707:4:0;38559:161::o;38726:156::-;38779:6;38813:5;38806:4;:12;38798:46;;;;-1:-1:-1;;;38798:46:0;;;;;;;:::i;39359:402::-;39565:15;-1:-1:-1;;;;;39565:29:0;;39609:7;39639:9;39687:32;;;39721:7;39730:11;39664:78;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;39664:78:0;;;;;;;;;;;;;;-1:-1:-1;;;;;39664:78:0;;;;;;;;39565:188;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39359:402;;;;:::o;6723:343::-;6809:7;6911:12;6904:5;6896:28;;;;-1:-1:-1;;;6896:28:0;;;;;;;;:::i;:::-;;6935:9;6951:1;6947;:5;;;;;;;6723:343;-1:-1:-1;;;;;6723:343:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;97:33;72:20;97:33;:::i;142:134::-;220:13;;238:33;220:13;238:33;:::i;1470:336::-;;;1584:3;1577:4;1569:6;1565:17;1561:27;1551:2;;-1:-1;;1592:12;1551:2;-1:-1;1622:20;;1662:18;1651:30;;1648:2;;;-1:-1;;1684:12;1648:2;1728:4;1720:6;1716:17;1704:29;;1779:3;1728:4;1759:17;1720:6;1745:32;;1742:41;1739:2;;;1796:1;;1786:12;4265:132;4342:13;;41782:18;41771:30;;45250:34;;45240:2;;45298:1;;45288:12;4404:241;;4508:2;4496:9;4487:7;4483:23;4479:32;4476:2;;;-1:-1;;4514:12;4476:2;85:6;72:20;97:33;124:5;97:33;:::i;4652:263::-;;4767:2;4755:9;4746:7;4742:23;4738:32;4735:2;;;-1:-1;;4773:12;4735:2;226:6;220:13;238:33;265:5;238:33;:::i;5186:366::-;;;5307:2;5295:9;5286:7;5282:23;5278:32;5275:2;;;-1:-1;;5313:12;5275:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;5365:63;-1:-1;5465:2;5504:22;;72:20;97:33;72:20;97:33;:::i;:::-;5473:63;;;;5269:283;;;;;:::o;5559:1497::-;;;;;;;;;;;;5838:3;5826:9;5817:7;5813:23;5809:33;5806:2;;;-1:-1;;5845:12;5806:2;97:33;85:6;72:20;97:33;:::i;:::-;85:6;72:20;5897:63;;97:33;5997:2;6040:9;6036:22;72:20;97:33;:::i;:::-;5997:2;6040:9;6036:22;72:20;6005:63;;6157:18;;6133:2;6122:9;6118:18;6105:32;6146:30;6143:2;;;-1:-1;;6179:12;6143:2;6217:64;6273:7;6133:2;6122:9;6118:18;6105:32;6253:9;6249:22;6217:64;:::i;:::-;6199:82;;-1:-1;6199:82;-1:-1;6318:2;6357:22;;4054:20;;-1:-1;6454:3;6439:19;;6426:33;6468:30;-1:-1;6465:2;;;-1:-1;;6501:12;6465:2;;6539:64;6595:7;6454:3;6443:9;6439:19;6426:33;6575:9;6571:22;6539:64;:::i;:::-;6521:82;;-1:-1;6521:82;-1:-1;6640:3;6680:22;;4054:20;;-1:-1;6749:3;6789:22;;4054:20;;-1:-1;6877:53;6922:7;6858:3;6898:22;;6877:53;:::i;:::-;6867:63;;6987:53;7032:7;6967:3;7012:9;7008:22;6987:53;:::i;:::-;6976:64;;5800:1256;;;;;;;;;;;;;;:::o;7063:366::-;;;7184:2;7172:9;7163:7;7159:23;7155:32;7152:2;;;-1:-1;;7190:12;7152:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;7242:63;7342:2;7381:22;;;;1386:20;;-1:-1;;;7146:283::o;7436:490::-;;;;7576:2;7564:9;7555:7;7551:23;7547:32;7544:2;;;-1:-1;;7582:12;7544:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;7634:63;-1:-1;7762:2;7747:18;;7734:32;7786:18;7775:30;;7772:2;;;-1:-1;;7808:12;7772:2;7846:64;7902:7;7893:6;7882:9;7878:22;7846:64;:::i;:::-;7538:388;;7828:82;;-1:-1;7828:82;;-1:-1;;;;7538:388::o;7933:392::-;;8073:2;;8061:9;8052:7;8048:23;8044:32;8041:2;;;-1:-1;;8079:12;8041:2;8130:17;8124:24;8168:18;;8160:6;8157:30;8154:2;;;-1:-1;;8190:12;8154:2;8292:6;8281:9;8277:22;;;582:3;575:4;567:6;563:17;559:27;549:2;;-1:-1;;590:12;549:2;630:6;624:13;8168:18;38103:6;38100:30;38097:2;;;-1:-1;;38133:12;38097:2;8073;38170:6;38166:17;;;652:80;8073:2;38166:17;38231:15;652:80;:::i;:::-;760:21;;;817:14;;;;792:17;;;897:27;;;;;894:36;-1:-1;891:2;;;-1:-1;;933:12;891:2;-1:-1;959:10;;953:217;978:6;975:1;972:13;953:217;;;1058:48;1102:3;1090:10;1058:48;:::i;:::-;1046:61;;1000:1;993:9;;;;;1121:14;;;;1149;;953:217;;;-1:-1;8210:99;8035:290;-1:-1;;;;;;;;8035:290::o;8332:257::-;;8444:2;8432:9;8423:7;8419:23;8415:32;8412:2;;;-1:-1;;8450:12;8412:2;1265:6;1259:13;44540:5;40693:13;40686:21;44518:5;44515:32;44505:2;;-1:-1;;44551:12;8596:360;;8720:2;8708:9;8699:7;8695:23;8691:32;8688:2;;;-1:-1;;8726:12;8688:2;8777:17;8771:24;8815:18;;8807:6;8804:30;8801:2;;;-1:-1;;8837:12;8801:2;8923:6;8912:9;8908:22;;;1927:3;1920:4;1912:6;1908:17;1904:27;1894:2;;-1:-1;;1935:12;1894:2;1975:6;1969:13;8815:18;38398:6;38395:30;38392:2;;;-1:-1;;38428:12;38392:2;1997:64;38501:9;38482:17;;-1:-1;;38478:33;8720:2;38559:15;1997:64;:::i;:::-;1988:73;;2081:6;2074:5;2067:21;2185:3;8720:2;2176:6;2109;2167:16;;2164:25;2161:2;;;-1:-1;;2192:12;2161:2;2212:39;2244:6;8720:2;2143:5;2139:16;8720:2;2109:6;2105:17;2212:39;:::i;:::-;-1:-1;8857:83;8682:274;-1:-1;;;;8682:274::o;8963:498::-;;;9132:9;9123:7;9119:23;9144:3;9119:23;9115:33;9112:2;;;-1:-1;;9151:12;9112:2;3156:4;3135:19;3131:30;3128:2;;;-1:-1;;3164:12;3128:2;3192:20;3156:4;3192:20;:::i;:::-;3789:6;3783:13;3801:33;3828:5;3801:33;:::i;:::-;3272:86;;3422:2;3487:22;;3783:13;3801:33;3783:13;3801:33;:::i;:::-;3422:2;3437:16;;3430:86;3617:59;3672:3;3584:2;3648:22;;3617:59;:::i;:::-;3584:2;3603:5;3599:16;3592:85;9203:96;;;;3584:2;2586:19;;;;2582:30;2579:2;;;-1:-1;;2615:12;2579:2;;2643:20;3584:2;2643:20;:::i;:::-;3156:4;9417:9;9413:22;3783:13;-1:-1;;;;;44907:5;41311:46;44882:5;44879:35;44869:2;;-1:-1;;44918:12;44869:2;2728:86;;2913:59;2968:3;2944:22;;;2913:59;:::i;:::-;3422:2;2899:5;2895:16;2888:85;9344:101;;;;9106:355;;;;;:::o;9468:263::-;;9583:2;9571:9;9562:7;9558:23;9554:32;9551:2;;;-1:-1;;9589:12;9551:2;3930:6;3924:13;41570:48;45031:5;41559:60;45006:5;45003:35;44993:2;;-1:-1;;45042:12;9738:263;;9853:2;9841:9;9832:7;9828:23;9824:32;9821:2;;;-1:-1;;9859:12;9821:2;-1:-1;4202:13;;9815:186;-1:-1;9815:186::o;10008:435::-;;;10158:2;10146:9;10137:7;10133:23;10129:32;10126:2;;;-1:-1;;10164:12;10126:2;4208:6;4202:13;10216:74;;10327:2;10399:9;10395:22;2361:13;44788:1;44781:5;44778:12;44768:2;;-1:-1;;44794:12;10748:152;44051:2;44047:14;-1:-1;;44047:14;10837:58;;10831:69::o;12947:343::-;;13089:5;38850:12;39392:6;39387:3;39380:19;13182:52;13227:6;39429:4;39424:3;39420:14;39429:4;13208:5;13204:16;13182:52;:::i;:::-;38501:9;43940:14;-1:-1;;43936:28;13246:39;;;;39429:4;13246:39;;13037:253;-1:-1;;13037:253::o;21712:1794::-;;40791:66;;11872:5;40780:78;11831:3;11824:56;40791:66;11872:5;40780:78;22259:1;22254:3;22250:11;11824:56;;44047:14;;;10887:5;44051:2;44047:14;;22358:11;22254:3;22358:11;10837:58;44047:14;10887:5;44051:2;44047:14;;22468:12;22254:3;22468:12;10837:58;;11993:5;22579:12;22254:3;22579:12;11963:37;13457:5;38850:12;13568:52;13613:6;22690:12;22254:3;22690:12;13601:4;13594:5;13590:16;13568:52;:::i;:::-;13641:6;22254:3;13632:16;;;11993:5;22690:12;13632:16;;11963:37;11993:5;22912:12;13632:16;22912:12;11963:37;11993:5;23023:12;13632:16;23023:12;11963:37;11993:5;23134:12;13632:16;23134:12;11963:37;23268:76;23245:12;13632:16;23245:12;23330:7;23268:76;:::i;:::-;23380;23357:12;13632:16;23357:12;23442:7;23380:76;:::i;:::-;23469:12;;;22152:1354;-1:-1;;;;;;;;;;;;;;22152:1354::o;23513:291::-;;43083:6;43078:3;43073;43060:30;43121:16;;43114:27;;;43121:16;23657:147;-1:-1;23657:147::o;23811:271::-;;13457:5;38850:12;13568:52;13613:6;13608:3;13601:4;13594:5;13590:16;13568:52;:::i;:::-;13632:16;;;;;23945:137;-1:-1;;23945:137::o;24089:520::-;15354:66;15334:87;;15318:2;15440:12;;11963:37;;;;24572:12;;;24306:303::o;24616:222::-;-1:-1;;;;;41431:54;;;;10699:37;;24743:2;24728:18;;24714:124::o;24845:333::-;-1:-1;;;;;41431:54;;;10699:37;;41431:54;;25164:2;25149:18;;10699:37;25000:2;24985:18;;24971:207::o;25185:528::-;;-1:-1;;;;;41442:42;40503:5;41431:54;10706:3;10699:37;41442:42;40503:5;41431:54;25550:2;25539:9;25535:18;10699:37;;25386:2;25587;25576:9;25572:18;25565:48;25627:76;25386:2;25375:9;25371:18;25689:6;25627:76;:::i;25720:640::-;;-1:-1;;;;;41442:42;40503:5;41431:54;10706:3;10699:37;41442:42;40503:5;41431:54;26114:2;26103:9;26099:18;10699:37;;11993:5;26197:2;26186:9;26182:18;11963:37;25949:3;26234:2;26223:9;26219:18;26212:48;26274:76;25949:3;25938:9;25934:19;26336:6;26274:76;:::i;26367:437::-;;-1:-1;;;;;10729:5;41431:54;10706:3;10699:37;26550:2;26668;26657:9;26653:18;26646:48;39392:6;26550:2;26539:9;26535:18;39380:19;43083:6;43078:3;39420:14;26539:9;39420:14;43060:30;43121:16;;;39420:14;43121:16;;;43114:27;;;;38501:9;43940:14;;;-1:-1;;43936:28;12553:39;;;26521:283;-1:-1;;26521:283::o;26811:441::-;-1:-1;;;;;41431:54;;;;10699:37;;20825:23;;-1:-1;;;;;41311:46;27238:2;27223:18;;;21163:37;;;;20990:16;20984:23;41782:18;41771:30;21059:14;;;21550:36;27020:2;27005:18;;26991:261::o;27259:333::-;-1:-1;;;;;41431:54;;;;10699:37;;27578:2;27563:18;;11963:37;27414:2;27399:18;;27385:207::o;27599:366::-;27774:2;27788:47;;;38850:12;;27759:18;;;39380:19;;;27599:366;;27774:2;38705:14;;;;39420;;;;27599:366;11339:257;11364:6;11361:1;11358:13;11339:257;;;11425:13;;41021:66;41010:78;12230:36;;39236:14;;;;10600;;;;11386:1;11379:9;11339:257;;;-1:-1;27841:114;;27745:220;-1:-1;;;;;;27745:220::o;27972:210::-;40693:13;;40686:21;11691:34;;28093:2;28078:18;;28064:118::o;28189:548::-;11963:37;;;41884:4;41873:16;;;;28557:2;28542:18;;21665:35;28640:2;28625:18;;11963:37;28723:2;28708:18;;11963:37;28396:3;28381:19;;28367:370::o;28744:417::-;;28917:2;28938:17;28931:47;28992:76;28917:2;28906:9;28902:18;29054:6;28992:76;:::i;:::-;28984:84;;11993:5;29147:2;29136:9;29132:18;11963:37;28888:273;;;;;:::o;30003:310::-;;30150:2;30171:17;30164:47;30225:78;30150:2;30139:9;30135:18;30289:6;30225:78;:::i;30320:416::-;30520:2;30534:47;;;14951:2;30505:18;;;39380:19;14987:24;39420:14;;;14967:45;15031:12;;;30491:245::o;30743:416::-;30943:2;30957:47;;;15691:2;30928:18;;;39380:19;15727:21;39420:14;;;15707:42;15768:12;;;30914:245::o;31166:416::-;31366:2;31380:47;;;16019:2;31351:18;;;39380:19;16055:29;39420:14;;;16035:50;16104:12;;;31337:245::o;31589:416::-;31789:2;31803:47;;;16355:2;31774:18;;;39380:19;16391:29;39420:14;;;16371:50;16440:12;;;31760:245::o;32012:416::-;32212:2;32226:47;;;16691:2;32197:18;;;39380:19;16727:32;39420:14;;;16707:53;16779:12;;;32183:245::o;32435:416::-;32635:2;32649:47;;;17030:2;32620:18;;;39380:19;17066:28;39420:14;;;17046:49;17114:12;;;32606:245::o;32858:416::-;33058:2;33072:47;;;17365:2;33043:18;;;39380:19;17401:33;39420:14;;;17381:54;17454:12;;;33029:245::o;33281:416::-;33481:2;33495:47;;;17705:2;33466:18;;;39380:19;17741:23;39420:14;;;17721:44;17784:12;;;33452:245::o;33704:416::-;33904:2;33918:47;;;18035:2;33889:18;;;39380:19;18071:28;39420:14;;;18051:49;18119:12;;;33875:245::o;34127:416::-;34327:2;34341:47;;;18370:2;34312:18;;;39380:19;18406:34;39420:14;;;18386:55;18475:3;18461:12;;;18454:25;18498:12;;;34298:245::o;34550:416::-;34750:2;34764:47;;;18749:2;34735:18;;;39380:19;18785:24;39420:14;;;18765:45;18829:12;;;34721:245::o;34973:416::-;35173:2;35187:47;;;19080:2;35158:18;;;39380:19;19116:23;39420:14;;;19096:44;19159:12;;;35144:245::o;35396:416::-;35596:2;35610:47;;;19410:2;35581:18;;;39380:19;19446:24;39420:14;;;19426:45;19490:12;;;35567:245::o;35819:416::-;36019:2;36033:47;;;19741:2;36004:18;;;39380:19;19777:29;39420:14;;;19757:50;19826:12;;;35990:245::o;36242:416::-;36442:2;36456:47;;;20077:2;36427:18;;;39380:19;20113:32;39420:14;;;20093:53;20165:12;;;36413:245::o;36665:416::-;36865:2;36879:47;;;20416:2;36850:18;;;39380:19;20452:33;39420:14;;;20432:54;20505:12;;;36836:245::o;37088:222::-;11963:37;;;37215:2;37200:18;;37186:124::o;37317:365::-;11963:37;;;37488:2;37473:18;;44166:1;44156:12;;44146:2;;44172:9;44146:2;42947:42;37668:2;37657:9;37653:18;14294:66;37459:223;;;;;:::o;37689:256::-;37751:2;37745:9;37777:17;;;37852:18;37837:34;;37873:22;;;37834:62;37831:2;;;37909:1;;37899:12;37831:2;37751;37918:22;37729:216;;-1:-1;37729:216::o;40098:318::-;;;40248:8;40236:10;40233:24;40230:2;;;-1:-1;;40260:12;40230:2;40295:6;40285:8;40282:20;40279:2;;;-1:-1;;40305:12;40279:2;-1:-1;;40337:31;;;40386:25;;;;;-1:-1;40224:192::o;43156:268::-;43221:1;43228:101;43242:6;43239:1;43236:13;43228:101;;;43309:11;;;43303:18;43290:11;;;43283:39;43264:2;43257:10;43228:101;;;43344:6;43341:1;43338:13;43335:2;;;43221:1;43400:6;43395:3;43391:16;43384:27;43335:2;;43205:219;;;:::o;44195:117::-;-1:-1;;;;;44282:5;41431:54;44257:5;44254:35;44244:2;;44303:1;;44293:12;44820:117;-1:-1;;;;;44907:5;41311:46;44882:5;44879:35;44869:2;;44928:1;;44918:12

ipfs://49c9013192ef272eca90edb38188c4c5c8e88cca2b8992227345105c5bbfaa33