Merge pull request #366 from derekpierre/secreto

Signing POC

Author: derekpierre

ape-config.yaml

@@ -33,5 +33,7 @@ ethereum:
     transaction_acceptance_timeout: 600 # 10 minutes
 
 test:
+  provider:
+    chain_id: 131277322940537  # ensure ape doesn't change chain id to 1337
   mnemonic: test test test test test test test test test test test junk
   number_of_accounts: 40

contracts/contracts/coordination/IL1Sender.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title IL1Sender
+ * @notice Interface for sending data to the L2 receiver contract.
+ */
+interface IL1Sender {
+    /**
+     * @notice Sends data to the L2 receiver contract.
+     * @param target The address of the target contract on L2.
+     * @param data The data to be sent to the target contract.
+     */
+    function sendData(address target, bytes calldata data) external;
+}

contracts/contracts/coordination/IL2Receiver.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title IL2Receiver
+ * @notice Interface for receiving data from the L1 sender contract.
+ */
+interface IL2Receiver {
+    /**
+     * @notice Receives data from the L1 sender contract.
+     * @param data The data sent from the L1 sender contract.
+     */
+    function recvData(bytes calldata data) external;
+}

contracts/contracts/coordination/ISigningCoordinatorChild.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title ISigningCoordinatorChild
+ * @notice Interface for x-chain interactions from SigningCoordinator to Child
+ */
+interface ISigningCoordinatorChild {
+    event CohortMultisigDeployed(uint32 indexed cohortId, address multisig);
+    event CohortMultisigUpdated(
+        uint32 indexed cohortId,
+        address multisig,
+        address[] signers,
+        uint16 threshold,
+        bool clearSigners
+    );
+
+    function deployCohortMultiSig(
+        uint32 cohortId,
+        address[] calldata signers,
+        uint16 threshold
+    ) external;
+
+    function updateMultiSigParameters(
+        uint32 cohortId,
+        address[] calldata signers,
+        uint16 threshold,
+        bool clearSigners
+    ) external;
+}

contracts/contracts/coordination/IThresholdSigningMultisig.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IThresholdSigningMultisig {
+    function initialize(address[] memory, uint16, address) external;
+
+    function updateMultiSigParameters(
+        address[] calldata signers,
+        uint16 threshold,
+        bool clearSigners
+    ) external;
+}

contracts/contracts/coordination/OpL1Sender.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin-upgradeable/contracts/proxy/utils/Initializable.sol";
+import "./IL1Sender.sol";
+import "./IL2Receiver.sol";
+
+interface ICrossDomainMessenger {
+    function sendMessage(address target, bytes calldata message, uint32 gasLimit) external;
+}
+
+/**
+ * @title OpL1Sender
+ * @notice Optimism-based contract responsible for sending data
+ *         to the L2 receiver contract via the bridge messenger.
+ */
+contract OpL1Sender is IL1Sender, Initializable {
+    ICrossDomainMessenger public immutable messenger;
+    address public immutable dispatcher;
+    uint32 public immutable gasLimit;
+    IL2Receiver public l2Receiver;
+
+    /**
+     * @param _dispatcher The address of the dispatcher contract.
+     * @param _messenger The address of the CrossDomainMessenger contract.
+     * @param _gasLimit The gas limit for the message.
+     */
+    constructor(address _dispatcher, ICrossDomainMessenger _messenger, uint32 _gasLimit) {
+        dispatcher = _dispatcher;
+        messenger = _messenger;
+        gasLimit = _gasLimit;
+    }
+
+    function initialize(IL2Receiver _l2Receiver) external initializer {
+        l2Receiver = _l2Receiver;
+    }
+
+    /**
+     * @notice Sends data to the L2 receiver contract via the messenger.
+     * @param target The address of the target contract on L2.
+     * @param data The data to be sent to the target contract.
+     */
+    function sendData(address target, bytes calldata data) external {
+        require(dispatcher == msg.sender, "Unauthorized caller");
+        bytes memory payload = abi.encode(target, data);
+        bytes memory callData = abi.encodeWithSelector(l2Receiver.recvData.selector, payload);
+        messenger.sendMessage(address(l2Receiver), callData, gasLimit);
+    }
+}

contracts/contracts/coordination/OpL2Receiver.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "./IL2Receiver.sol";
+
+interface ICrossDomainMessenger {
+    function xDomainMessageSender() external view returns (address);
+}
+
+/**
+ * @title OpL2Receiver
+ * @notice Contract is used to receive data from the L1 sender contract via the bridge messenger.
+ */
+contract OpL2Receiver is IL2Receiver {
+    address public immutable messenger;
+    address public immutable l1Sender;
+
+    event Executed(address target, bytes result);
+
+    /**
+     * @param _l1Sender The address of the L1 sender contract.
+     * @param _messenger The address of the CrossDomainMessenger contract.
+     */
+    constructor(address _l1Sender, address _messenger) {
+        l1Sender = _l1Sender;
+        messenger = _messenger;
+    }
+
+    /**
+     * @notice Receives data from the L1 sender contract via the messenger.
+     * @param data The data sent from the L1 sender contract.
+     */
+    function recvData(bytes calldata data) external {
+        require(messenger == msg.sender, "Not from messenger");
+        require(
+            l1Sender == ICrossDomainMessenger(messenger).xDomainMessageSender(),
+            "Invalid sender"
+        );
+        (address target, bytes memory callData) = abi.decode(data, (address, bytes));
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory result) = target.call(callData);
+        require(success, "L2 Receiver Execution failed");
+
+        emit Executed(target, result);
+    }
+}