🦜 Legacy impl

🦜 Legacy impl

Author: mubaris

Diff for: deployments.json

@@ -15,7 +15,9 @@
     "impls": "0x331Cf6E3E59B18a8bc776A0F652aF9E2b42781c5",
     "account": "0xFa923AA6b4DF5bea456DF37FA044B37F0FDDCdb4",
     "defaultImpl": "0x684BBb31eb2F7891523fAfc2CC5A0fB0a45C4DC4",
-    "mainImpl": "0x4c587a067636fCEF2B6B171535B545845067843a"
+    "mainImpl": "0x4c587a067636fCEF2B6B171535B545845067843a",
+    "legacyConnectors": "0xbB0A24A685aEC75926E9c51b7DCF29b69f7e2A33",
+    "legacyImpl": "0x12a4CC40a8F89E40F8C849c2F89741D5C9590a14"
   },
   "optimism-goerli": {
     "index": "0xC7a069dD24178DF00914d49Bf674A40A1420CF01",
@@ -42,6 +44,8 @@
     "impls": "0x6c4c4971936F091Ba351a4e9B621FcCDC03455e4",
     "account": "0xA8BBBf760A0fFc28A5B1fF6AFe86280061445EE9",
     "defaultImpl": "0xa4c1B0B3a8B97F9951e1Bf156E9Fe19c1a17c3Db",
-    "mainImpl": "0x3EEBDDC12D6dd5fc0603998384A6EEaD1B126045"
+    "mainImpl": "0x3EEBDDC12D6dd5fc0603998384A6EEaD1B126045",
+    "legacyConnectors": "0x8eBD88707b3D71f511b714aF696fAE44b4D3d3A8",
+    "legacyImpl": "0x1796B87e76Ca876aC06cE4F96C6b4cAda1d12f2E"
   }
 }

Diff for: script/DeployLegacy.s.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import {Script} from "forge-std/Script.sol";
+import {console2} from "forge-std/console2.sol";
+
+import {LegacyImplementation} from "../src/accounts/LegacyImpl.sol";
+import {PolyLegacyConnectors} from "../src/registry/LegacyConnectors.sol";
+import {PolyImplementations} from "../src/registry/Implementations.sol";
+
+contract DeployLegacy is Script {
+    function run() external {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
+
+        address polyIndex = 0x2d4937ED79D434290c4baeA6d390b78c0bf907d8;
+        PolyImplementations impls = PolyImplementations(0x331Cf6E3E59B18a8bc776A0F652aF9E2b42781c5);
+
+        PolyLegacyConnectors legacyConnectors = new PolyLegacyConnectors(polyIndex);
+        LegacyImplementation legacyImpl = new LegacyImplementation(polyIndex, address(legacyConnectors));
+
+        bytes4[] memory selectors = new bytes4[](1);
+        selectors[0] = LegacyImplementation.cast.selector;
+
+        address[] memory connectorsToAdd = new address[](1);
+        connectorsToAdd[0] = 0x3ba6A43ebf48520ea099ab07b411974f8494B390; // Base Synthetix Perp
+
+        impls.addImplementation(address(legacyImpl), selectors);
+        legacyConnectors.addConnectors(connectorsToAdd);
+
+        vm.stopBroadcast();
+    }
+}

Diff for: src/accounts/LegacyImpl.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import {Variables} from "./Variables.sol";
+
+/**
+ * @title FxWallet.
+ * @dev fx Wallet.
+ */
+interface ConnectorsInterface {
+    function isConnectors(address[] calldata connectorNames) external view returns (bool);
+}
+
+contract Constants is Variables {
+    // polyIndex Address.
+    address internal immutable polyIndex;
+    // Connectors Address.
+    address public immutable connectors;
+
+    constructor(address _polyIndex, address _connectors) {
+        connectors = _connectors;
+        polyIndex = _polyIndex;
+    }
+}
+
+contract LegacyImplementation is Constants {
+    constructor(address _polyIndex, address _connectors) Constants(_polyIndex, _connectors) {}
+
+    function decodeEvent(bytes memory response)
+        internal
+        pure
+        returns (string memory _eventCode, bytes memory _eventParams)
+    {
+        if (response.length > 0) {
+            (_eventCode, _eventParams) = abi.decode(response, (string, bytes));
+        }
+    }
+
+    event LogCast(
+        address indexed origin,
+        address indexed sender,
+        uint256 value,
+        address[] targets,
+        string[] eventNames,
+        bytes[] eventParams
+    );
+
+    receive() external payable {}
+
+    /**
+     * @dev Delegate the calls to Connector.
+     * @param _target Connector address
+     * @param _data CallData of function.
+     */
+    function spell(address _target, bytes memory _data) internal returns (bytes memory response) {
+        require(_target != address(0), "target-invalid");
+        assembly {
+            let succeeded := delegatecall(gas(), _target, add(_data, 0x20), mload(_data), 0, 0)
+            let size := returndatasize()
+
+            response := mload(0x40)
+            mstore(0x40, add(response, and(add(add(size, 0x20), 0x1f), not(0x1f))))
+            mstore(response, size)
+            returndatacopy(add(response, 0x20), 0, size)
+
+            switch iszero(succeeded)
+            case 1 {
+                // throw if delegatecall failed
+                returndatacopy(0x00, 0x00, size)
+                revert(0x00, size)
+            }
+        }
+    }
+
+    /**
+     * @dev This is the main function, Where all the different functions are called
+     * from Smart Account.
+     * @param _targets Array of Connector address.
+     * @param _datas Array of Calldata.
+     */
+    function cast(address[] calldata _targets, bytes[] calldata _datas, address _origin)
+        external
+        payable
+        returns (
+            bytes32 // Dummy return to fix polyIndex buildWithCast function
+        )
+    {
+        uint256 _length = _targets.length;
+        require(_auth[msg.sender] || msg.sender == polyIndex, "1: permission-denied");
+        require(_length != 0, "1: length-invalid");
+        require(_length == _datas.length, "1: array-length-invalid");
+
+        string[] memory eventNames = new string[](_length);
+        bytes[] memory eventParams = new bytes[](_length);
+
+        bool isOk = ConnectorsInterface(connectors).isConnectors(_targets);
+
+        require(isOk, "1: not-connector");
+
+        for (uint256 i = 0; i < _length; i++) {
+            bytes memory response = spell(_targets[i], _datas[i]);
+            (eventNames[i], eventParams[i]) = decodeEvent(response);
+        }
+
+        emit LogCast(_origin, msg.sender, msg.value, _targets, eventNames, eventParams);
+    }
+}

Diff for: src/registry/LegacyConnectors.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+/**
+ * @title PolyConnectors
+ * @dev Registry for Connectors.
+ */
+interface IndexInterface {
+    function master() external view returns (address);
+}
+
+interface ConnectorInterface {
+    function name() external view returns (string memory);
+}
+
+contract Controllers {
+    event LogController(address indexed addr, bool indexed isChief);
+
+    // PolyIndex Address.
+    address public immutable polyIndex;
+
+    constructor(address _polyIndex) {
+        polyIndex = _polyIndex;
+    }
+
+    // Enabled Chief(Address of Chief => bool).
+    mapping(address => bool) public chief;
+    // Enabled Connectors(Connector name => address).
+    mapping(address => bool) public connectors;
+
+    /**
+     * @dev Throws if the sender not is Master Address from PolyIndex
+     * or Enabled Chief.
+     */
+    modifier isChief() {
+        require(chief[msg.sender] || msg.sender == IndexInterface(polyIndex).master(), "not-an-chief");
+        _;
+    }
+
+    /**
+     * @dev Toggle a Chief. Enable if disable & vice versa
+     * @param _chiefAddress Chief Address.
+     */
+    function toggleChief(address _chiefAddress) external {
+        require(msg.sender == IndexInterface(polyIndex).master(), "toggleChief: not-master");
+        chief[_chiefAddress] = !chief[_chiefAddress];
+        emit LogController(_chiefAddress, chief[_chiefAddress]);
+    }
+}
+
+contract PolyLegacyConnectors is Controllers {
+    event LogConnectorAdded(address indexed connector);
+    event LogConnectorRemoved(address indexed connector);
+
+    constructor(address _polyIndex) Controllers(_polyIndex) {}
+
+    /**
+     * @dev Add Connectors
+     * @param _connectors Array of Connector Address.
+     */
+    function addConnectors(address[] calldata _connectors) external isChief {
+        for (uint256 i = 0; i < _connectors.length; i++) {
+            require(!connectors[_connectors[i]], "addConnectors: _connector added already");
+            require(_connectors[i] != address(0), "addConnectors: _connectors address not vaild");
+            ConnectorInterface(_connectors[i]).name(); // Checking if connector has function name()
+            connectors[_connectors[i]] = true;
+            emit LogConnectorAdded(_connectors[i]);
+        }
+    }
+
+    /**
+     * @dev Remove Connectors
+     * @param _connectors Array of Connector Addresses.
+     */
+    function removeConnectors(address[] calldata _connectors) external isChief {
+        for (uint256 i = 0; i < _connectors.length; i++) {
+            require(connectors[_connectors[i]], "removeConnectors: _connector not added to remove");
+            emit LogConnectorRemoved(_connectors[i]);
+            delete connectors[_connectors[i]];
+        }
+    }
+
+    /**
+     * @dev Check if Connector addresses are enabled.
+     * @param _connectors Array of Connector Addresses.
+     */
+    function isConnectors(address[] calldata _connectors) external view returns (bool isOk) {
+        isOk = true;
+        for (uint256 i = 0; i < _connectors.length; i++) {
+            if (!connectors[_connectors[i]]) {
+                return false;
+            }
+        }
+    }
+}