Updates with the latest from our downstream repo

.gitignore

@@ -19,4 +19,5 @@ artifacts
 out
 cache
 
-*.DS_Store
+*.DS_Store
+.idea/

.gitmodules

@@ -1,18 +1,18 @@
-[submodule "lib/openzeppelin-contracts"]
-	path = lib/openzeppelin-contracts
-	url = https://github.com/OpenZeppelin/openzeppelin-contracts
-[submodule "lib/openzeppelin-contracts-upgradeable"]
-	path = lib/openzeppelin-contracts-upgradeable
-	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
-[submodule "lib/solmate"]
-	path = lib/solmate
-	url = https://github.com/transmissions11/solmate
 [submodule "lib/eigenlayer-contracts"]
 	path = lib/eigenlayer-contracts
 	url = https://github.com/Layr-Labs/eigenlayer-contracts
 [submodule "lib/eigenlayer-middleware"]
 	path = lib/eigenlayer-middleware
 	url = https://github.com/Layr-Labs/eigenlayer-middleware
+[submodule "lib/solmate"]
+	path = lib/solmate
+	url = https://github.com/transmissions11/solmate
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-foundry-upgrades"]
+	path = lib/openzeppelin-foundry-upgrades
+	url = https://github.com/OpenZeppelin/openzeppelin-foundry-upgrades
+[submodule "lib/openzeppelin-contracts-upgradeable"]
+	path = lib/openzeppelin-contracts-upgradeable
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable

LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

foundry.toml

@@ -1,21 +1,13 @@
 [profile.default]
 src = "src"
 out = "out"
+ffi = true
+build_info = true
+ast = true
+extra_output = ["storageLayout", "abi", "metadata", "devdoc", "userdoc"]
 libs = ["lib"]
 gas_reports = ["*"]
-# Override the Solidity version (this overrides `auto_detect_solc`)
-solc_version = '0.8.20'
-via_ir = true
-optimizer = true
-optimizer_runs = 200
-verbosity = 4
-
-# Add caching settings
-cache = true
-cache_path = 'cache'
-
-# Optional: Force cache invalidation only when source files change
-force_cache = true
+solc_version = '0.8.28'
 
 [fmt]
 bracket_spacing = false
@@ -26,7 +18,6 @@ number_underscore = "thousands"
 quote_style = "double"
 tab_width = 4
 
-
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
 
 [profile.fast]

src/ServiceManager.sol

@@ -2,17 +2,18 @@
 pragma solidity ^0.8.12;
 
 import {OwnableUpgradeable} from "openzeppelin-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "openzeppelin-upgradeable/proxy/utils/Initializable.sol";
 
 import {IDelegationManager} from "eigenlayer-contracts/src/contracts/interfaces/IDelegationManager.sol";
 import {IAVSDirectory} from "eigenlayer-contracts/src/contracts/interfaces/IAVSDirectory.sol";
 import {ISignatureUtils} from "eigenlayer-contracts/src/contracts/interfaces/ISignatureUtils.sol";
 import {IStrategy} from "eigenlayer-contracts/src/contracts/interfaces/IStrategy.sol";
-import {ECDSA} from "openzeppelin/utils/cryptography/ECDSA.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
 import {IStakeRegistry} from "./interfaces/IStakeRegistry.sol";
 import {IPredicateManager, Task, SignatureWithSaltAndExpiry} from "./interfaces/IPredicateManager.sol";
 
-contract ServiceManager is IPredicateManager, OwnableUpgradeable {
+contract ServiceManager is IPredicateManager, Initializable, OwnableUpgradeable {
     error ServiceManager__Unauthorized();
     error ServiceManager__InvalidOperator();
     error ServiceManager__InvalidStrategy();
@@ -90,10 +91,6 @@ contract ServiceManager is IPredicateManager, OwnableUpgradeable {
         _;
     }
 
-    constructor() {
-        _disableInitializers();
-    }
-
     function initialize(
         address _owner,
         address _aggregator,
@@ -233,7 +230,7 @@ contract ServiceManager is IPredicateManager, OwnableUpgradeable {
     function registerOperatorToAVS(
         address _operatorSigningKey,
         SignatureWithSaltAndExpiry memory _operatorSignature
-    ) external onlyPermissionedOperator {
+    ) external {
         require(
             signingKeyToOperator[_operatorSigningKey] == address(0),
             "ServiceManager.registerOperatorToAVS: operator already registered"
@@ -277,6 +274,7 @@ contract ServiceManager is IPredicateManager, OwnableUpgradeable {
      * @notice Deploys a policy for which clients can use
      * @param _policyID is a unique identifier
      * @param _policy is set of formatted rules
+     * @param _quorumThreshold is the number of signatures required to validate a task
      */
     function deployPolicy(
         string memory _policyID,

src/examples/MetaCoin.sol

@@ -1,64 +1,35 @@
 // SPDX-License-Identifier: MIT
-// Tells the Solidity compiler to compile only from v0.8.13 to v0.9.0
 pragma solidity ^0.8.12;
 
-import {Ownable} from "openzeppelin/access/Ownable.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 
-import {PredicateClient} from "../mixins/PredicateClient.sol";
-import {PredicateMessage} from "../interfaces/IPredicateClient.sol";
-import {IPredicateManager} from "../interfaces/IPredicateManager.sol";
-
-// This is just a simple example of a coin-like contract.
-// It is not ERC20 compatible and cannot be expected to talk to other
-// coin/token contracts.
-
-contract MetaCoin is PredicateClient, Ownable {
+contract MetaCoin is Ownable {
     mapping(address => uint256) public balances;
 
     event Transfer(address indexed _from, address indexed _to, uint256 _value);
 
-    constructor(address _owner, address _serviceManager, string memory _policyID) {
+    constructor(
+        address _owner
+    ) Ownable() {
         balances[_owner] = 10_000_000_000_000;
-        _initPredicateClient(_serviceManager, _policyID);
-        _transferOwnership(_owner);
-    }
-
-    function sendCoin(address receiver, uint256 amount, PredicateMessage calldata predicateMessage) public payable {
-        bytes memory encodedSigAndArgs = abi.encodeWithSignature("_sendCoin(address,uint256)", receiver, amount);
-        require(
-            _authorizeTransaction(predicateMessage, encodedSigAndArgs, msg.sender, msg.value),
-            "MetaCoin: unauthorized transaction"
-        );
-
-        // business logic function that is protected
-        _sendCoin(receiver, amount);
-    }
-
-    // @inheritdoc IPredicateClient
-    function setPolicy(
-        string memory _policyID
-    ) external onlyOwner {
-        _setPolicy(_policyID);
+        transferOwnership(_owner);
     }
 
-    // @inheritdoc IPredicateClient
-    function setPredicateManager(
-        address _predicateManager
-    ) public onlyOwner {
-        _setPredicateManager(_predicateManager);
+    function sendCoin(address _receiver, uint256 _amount) external payable {
+        _sendCoin(_receiver, _amount);
     }
 
     // business logic function that is protected
-    function _sendCoin(address receiver, uint256 amount) internal {
-        require(balances[msg.sender] >= amount, "MetaCoin: insufficient balance");
-        balances[msg.sender] -= amount;
-        balances[receiver] += amount;
-        emit Transfer(msg.sender, receiver, amount);
+    function _sendCoin(address _receiver, uint256 _amount) internal {
+        require(balances[msg.sender] >= _amount, "MetaCoin: insufficient balance");
+        balances[msg.sender] -= _amount;
+        balances[_receiver] += _amount;
+        emit Transfer(msg.sender, _receiver, _amount);
     }
 
     function getBalance(
-        address addr
+        address _addr
     ) public view returns (uint256) {
-        return balances[addr];
+        return balances[_addr];
     }
 }

src/examples/inheritance/MetaCoin.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+// Tells the Solidity compiler to compile only from v0.8.13 to v0.9.0
+pragma solidity ^0.8.12;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {PredicateClient} from "../../mixins/PredicateClient.sol";
+import {PredicateMessage} from "../../interfaces/IPredicateClient.sol";
+import {IPredicateManager} from "../../interfaces/IPredicateManager.sol";
+
+contract MetaCoin is PredicateClient, Ownable {
+    mapping(address => uint256) public balances;
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+
+    constructor(address _owner, address _serviceManager, string memory _policyID) Ownable() {
+        balances[_owner] = 10_000_000_000_000;
+        _initPredicateClient(_serviceManager, _policyID);
+        transferOwnership(_owner);
+    }
+
+    function sendCoin(address _receiver, uint256 _amount, PredicateMessage calldata _message) external payable {
+        bytes memory encodedSigAndArgs = abi.encodeWithSignature("_sendCoin(address,uint256)", _receiver, _amount);
+        require(
+            _authorizeTransaction(_message, encodedSigAndArgs, msg.sender, msg.value),
+            "MetaCoin: unauthorized transaction"
+        );
+
+        // business logic function that is protected
+        _sendCoin(_receiver, _amount);
+    }
+
+    function setPolicy(
+        string memory _policyID
+    ) external onlyOwner {
+        _setPolicy(_policyID);
+    }
+
+    function setPredicateManager(
+        address _predicateManager
+    ) public onlyOwner {
+        _setPredicateManager(_predicateManager);
+    }
+
+    function _sendCoin(address _receiver, uint256 _amount) internal {
+        require(balances[msg.sender] >= _amount, "MetaCoin: insufficient balance");
+        balances[msg.sender] -= _amount;
+        balances[_receiver] += _amount;
+        emit Transfer(msg.sender, _receiver, _amount);
+    }
+
+    function getBalance(
+        address _addr
+    ) public view returns (uint256) {
+        return balances[_addr];
+    }
+}

src/examples/proxy/IPredicateProtected.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+// Tells the Solidity compiler to compile only from v0.8.13 to v0.9.0
+pragma solidity ^0.8.12;
+
+interface IPredicateProtected {
+    function getPredicateProxy() external view returns (address);
+    function setPredicateProxy(
+        address _predicateProxyAddress
+    ) external;
+    function enablePredicateProxy() external;
+    function disablePredicateProxy() external;
+}

src/examples/proxy/MetaCoin.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+// Tells the Solidity compiler to compile only from v0.8.13 to v0.9.0
+pragma solidity ^0.8.12;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {PredicateProtected} from "./PredicateProtected.sol";
+
+contract MetaCoin is Ownable, PredicateProtected {
+    mapping(address => uint256) public balances;
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+
+    constructor(address _owner, address _predicateProxyAddress) Ownable() {
+        balances[_owner] = 10_000_000_000_000;
+        _setPredicateProxy(_predicateProxyAddress);
+        transferOwnership(_owner);
+    }
+
+    function sendCoin(address _sender, address _receiver, uint256 _amount) external payable onlyPredicateProxy {
+        _sendCoin(_sender, _receiver, _amount);
+    }
+
+    function _sendCoin(address _sender, address _receiver, uint256 _amount) internal {
+        require(balances[_sender] >= _amount, "MetaCoin: insufficient balance");
+        balances[_sender] -= _amount;
+        balances[_receiver] += _amount;
+        emit Transfer(_sender, _receiver, _amount);
+    }
+
+    function getBalance(
+        address _addr
+    ) public view returns (uint256) {
+        return balances[_addr];
+    }
+
+    function setPredicateProxy(
+        address _predicateProxyAddress
+    ) external onlyOwner {
+        _setPredicateProxy(_predicateProxyAddress);
+    }
+
+    function enablePredicateProxy() external onlyOwner {
+        _enablePredicateProxy();
+    }
+
+    function disablePredicateProxy() external onlyOwner {
+        _disablePredicateProxy();
+    }
+}

src/examples/proxy/PredicateClientProxy.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+// Tells the Solidity compiler to compile only from v0.8.13 to v0.9.0
+pragma solidity ^0.8.12;
+
+import {PredicateClient} from "../../mixins/PredicateClient.sol";
+import {PredicateMessage} from "../../interfaces/IPredicateClient.sol";
+import {IPredicateManager} from "../../interfaces/IPredicateManager.sol";
+
+import {MetaCoin} from "./MetaCoin.sol";
+
+contract PredicateClientProxy is PredicateClient {
+    MetaCoin private _metaCoin;
+
+    constructor(address _metaCoinContract, address _serviceManager, string memory _policyID) {
+        _initPredicateClient(_serviceManager, _policyID);
+        _metaCoin = MetaCoin(_metaCoinContract);
+    }
+
+    function proxySendCoin(address _receiver, uint256 _amount, PredicateMessage calldata _message) external payable {
+        bytes memory encodedSigAndArgs = abi.encodeWithSignature("_sendCoin(address,uint256)", _receiver, _amount);
+        require(
+            _authorizeTransaction(_message, encodedSigAndArgs, msg.sender, msg.value),
+            "MetaCoin: unauthorized transaction"
+        );
+
+        _metaCoin.sendCoin{value: msg.value}(msg.sender, _receiver, _amount);
+    }
+
+    function setPolicy(
+        string memory _policyID
+    ) external {
+        _setPolicy(_policyID);
+    }
+
+    function setPredicateManager(
+        address _predicateManager
+    ) public {
+        _setPredicateManager(_predicateManager);
+    }
+}