Feat--recover-rewards-transmuter

foundry.toml

@@ -9,7 +9,7 @@ gas_reports = ["*"]
 via_ir = false
 sizes = true
 optimizer_runs=1000
-solc_version = '0.8.22'
+solc_version = '0.8.23'
 fs_permissions = [{ access = "read-write", path = "./scripts/foundry/transaction.json"}, { access = "read-write", path = "./scripts/foundry/transactions.json"}, { access = "read-write", path = "./lib/angle-tokens/scripts"}, { access = "read-write", path = "./scripts/proposals/transmuter/selectors.json"}, { access = "read-write", path = "./scripts/foundry/transmuter/updateFacets/selectors_replace.json"}, { access = "read-write", path = "./scripts/foundry/transmuter/updateFacets/selectors_add.json"}]
 
 ffi = true

helpers/createTx.sh

@@ -120,7 +120,7 @@ function main {
         read execute
 
         if [[ $execute == "yes" ]]; then
-            yarn submit:foundry
+            bun submit:foundry
         fi
     done
 }

package.json

@@ -12,7 +12,7 @@
     "prettier": "prettier --write ."
   },
   "devDependencies": {
-    "@angleprotocol/sdk": "^v2.28.19",
+    "@angleprotocol/sdk": "^v2.33.34",
     "@chainlink/contracts": "0.2.1",
     "@metamask/detect-provider": "1.2.0",
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
@@ -59,4 +59,4 @@
   "keywords": [],
   "author": "",
   "license": "ISC"
-}
+}

scripts/foundry/router/UpgradeRouter.s.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.19;
 
-import {TransparentUpgradeableProxy} from "oz/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {ITransparentUpgradeableProxy} from "oz/proxy/transparent/TransparentUpgradeableProxy.sol";
 import { MultiSend, Utils } from "../Utils.s.sol";
 import { Enum } from "safe/Safe.sol";
 import "../Constants.s.sol";
@@ -21,7 +21,7 @@ contract UpgradeRouter is Utils {
 
         if (chainId == CHAIN_LINEA) {
             {
-                bytes memory data = abi.encodeWithSelector(TransparentUpgradeableProxy.upgradeTo.selector, routerImpl);
+                bytes memory data = abi.encodeWithSelector(ITransparentUpgradeableProxy.upgradeTo.selector, routerImpl);
                 address to = router;
                 bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, data.length, data);
                 transactions = abi.encodePacked(transactions, internalTx);

scripts/foundry/transaction.json

@@ -1,8 +1,9 @@
 {
-  "additionalData": "0x89e1e82a0000000000000000000000000000000000000000000000000000000000000000",
-  "chainId": 8453,
-  "data": "0x8d80ff0a00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000079003ef3d8ba38ebe18db133cec108f4d14ce00dd9ae0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002489e1e82a000000000000000000000000000000000000000000000000000000000000000000000000000000",
+  "additionalData": "0x",
+  "chainId": 1,
+  "data": "0x8d80ff0a000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001b200222222fd79264bbe280b4986f6fefbc3524d0137000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000845c3eebda0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ca30c93b02514f86d5c86a6e375e3a330b435fb5000000000000000000000000a9ddd91249dfdd450e81e1c56ab60e1a62651701000000000000000000000000000000000000000000000011566924abcbc3d5eb00222222fd79264bbe280b4986f6fefbc3524d0137000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000845c3eebda00000000000000000000000000000000000000000000000000000000000000000000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0000000000000000000000000a9ddd91249dfdd450e81e1c56ab60e1a6265170100000000000000000000000000000000000000000000000026cc04d97b7c69610000000000000000000000000000",
   "operation": 1,
-  "to": "0xA1dabEF33b3B82c7814B6D82A79e50F4AC44102B",
+  "safe": "0xdC4e6DFe07EFCa50a197DF15D9200883eF4Eb1c8",
+  "to": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
   "value": 0
 }

scripts/foundry/transmuter/TransmuterAddCollateralEURCV.s.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.19;
+
+import { console } from "forge-std/console.sol";
+import "transmuter/transmuter/Storage.sol" as Storage;
+import { ITransmuter, ISettersGovernor, ISettersGuardian, ISwapper } from "transmuter/interfaces/ITransmuter.sol";
+import { Enum } from "safe/Safe.sol";
+import { MultiSend, Utils } from "../Utils.s.sol";
+import "../Constants.s.sol";
+
+contract TransmuterAddCollateralEURCV is Utils {
+    address public constant COLLATERAL_TO_ADD = 0x5F7827FDeb7c20b443265Fc2F40845B715385Ff2;
+
+    bytes oracleConfigCollatToAdd;
+    uint64[] public xFeeMint;
+    int64[] public yFeeMint;
+    uint64[] public xFeeBurn;
+    int64[] public yFeeBurn;
+    address public agToken;
+
+    function run() external {
+        uint256 chainId = vm.envUint("CHAIN_ID");
+
+        address safe = _chainToContract(chainId, ContractType.GovernorMultisig);
+        ITransmuter transmuter = ITransmuter(_chainToContract(chainId, ContractType.TransmuterAgEUR));
+        agToken = address(transmuter.agToken());
+        bytes memory transactions;
+
+        uint64[] memory xFeeBurn = new uint64[](1);
+        uint64[] memory xFeeMint = new uint64[](3);
+        int64[] memory yFeeMint = new int64[](xFeeMint.length);
+        int64[] memory yFeeBurn = new int64[](xFeeBurn.length);
+        xFeeBurn[0] = 1e9;
+        yFeeBurn[0] = 0.0005e9;
+
+        xFeeMint[0] = 0;
+        xFeeMint[1] = 0.29e9;
+        xFeeMint[2] = 0.30e9;
+        yFeeMint[0] = 0;
+        yFeeMint[1] = 0;
+        yFeeMint[2] = 100e9 - 1;
+
+        // Add the new collateral
+        {
+            address to = address(transmuter);
+            uint8 isDelegateCall = 0;
+            {
+                bytes memory readData;
+                bytes memory targetData;
+                oracleConfigCollatToAdd = abi.encode(
+                    Storage.OracleReadType.NO_ORACLE,
+                    Storage.OracleReadType.STABLE,
+                    readData,
+                    targetData,
+                    // With no oracle the below oracles are useless
+                    abi.encode(uint128(0), uint128(0))
+                );
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(ISettersGovernor.addCollateral.selector, COLLATERAL_TO_ADD);
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                // Mint fees
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.setFees.selector,
+                    COLLATERAL_TO_ADD,
+                    xFeeMint,
+                    yFeeMint,
+                    true
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                // Burn fees
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.setFees.selector,
+                    COLLATERAL_TO_ADD,
+                    xFeeBurn,
+                    yFeeBurn,
+                    false
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGovernor.setOracle.selector,
+                    COLLATERAL_TO_ADD,
+                    oracleConfigCollatToAdd
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.togglePause.selector,
+                    COLLATERAL_TO_ADD,
+                    Storage.ActionType.Mint
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.togglePause.selector,
+                    COLLATERAL_TO_ADD,
+                    Storage.ActionType.Burn
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, uint256(0), dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+        }
+
+        bytes memory payloadMultiSend = abi.encodeWithSelector(MultiSend.multiSend.selector, transactions);
+        _serializeJson(chainId, address(_chainToMultiSend(chainId)), uint256(0), payloadMultiSend, Enum.Operation.DelegateCall, hex"", safe);
+    }
+}

scripts/foundry/transmuter/TransmuterAddCollateralMWEURC.s.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.19;
+
+import { console } from "forge-std/console.sol";
+import "transmuter/transmuter/Storage.sol" as Storage;
+import { ITransmuter, ISettersGovernor, ISettersGuardian, ISwapper } from "transmuter/interfaces/ITransmuter.sol";
+import { Enum } from "safe/Safe.sol";
+import { MultiSend, Utils } from "../Utils.s.sol";
+import { MAX_MINT_FEE, MAX_BURN_FEE } from "transmuter/utils/Constants.sol";
+import "../Constants.s.sol";
+
+contract TransmuterAddCollateralMWEURC is Utils {
+    address public constant COLLATERAL_TO_ADD = 0xf24608E0CCb972b0b0f4A6446a0BBf58c701a026;
+
+    bytes oracleConfigCollatToAdd;
+    uint64[] public xFeeMint;
+    int64[] public yFeeMint;
+    uint64[] public xFeeBurn;
+    int64[] public yFeeBurn;
+    uint256 public capStablecoin;
+    address public agToken;
+
+    function run() external {
+        uint256 chainId = vm.envUint("CHAIN_ID");
+
+        ITransmuter transmuter = ITransmuter(_chainToContract(chainId, ContractType.TransmuterAgEUR));
+        agToken = address(transmuter.agToken());
+        bytes memory transactions;
+        uint8 isDelegateCall = 0;
+        address to = address(transmuter);
+        uint256 value = 0;
+
+        xFeeBurn = new uint64[](3);
+        xFeeMint = new uint64[](3);
+        yFeeMint = new int64[](xFeeMint.length);
+        yFeeBurn = new int64[](xFeeBurn.length);
+        xFeeBurn[0] = 1e9;
+        xFeeBurn[1] = 0.21e9;
+        xFeeBurn[2] = 0.20e9;
+        yFeeBurn[0] = 0.005e9;
+        yFeeBurn[1] = 0.005e9;
+        yFeeBurn[2] = int64(uint64(MAX_BURN_FEE));
+
+        xFeeMint[0] = 0;
+        xFeeMint[1] = 0.59e9;
+        xFeeMint[2] = 0.60e9;
+        yFeeMint[0] = 0.0005e9;
+        yFeeMint[1] = 0.0005e9;
+        yFeeMint[2] = int64(uint64(MAX_MINT_FEE));
+
+        capStablecoin = 2_000_000 ether;
+
+        // Add the new collateral
+        {
+            {
+                bytes memory data = abi.encodeWithSelector(ISettersGovernor.addCollateral.selector, COLLATERAL_TO_ADD);
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                // Mint fees
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.setFees.selector,
+                    COLLATERAL_TO_ADD,
+                    xFeeMint,
+                    yFeeMint,
+                    true
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                // Burn fees
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.setFees.selector,
+                    COLLATERAL_TO_ADD,
+                    xFeeBurn,
+                    yFeeBurn,
+                    false
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+
+            {
+                address oracle = 0xa7ea0d40C246b876F76713Ba9a9A95f3f18AB794;
+                uint256 normalizationFactor = 1e18;
+                bytes memory targetData = abi.encode(1000794000000000000); // 1008235463728948111
+                bytes memory readData = abi.encode(oracle, normalizationFactor);
+                oracleConfigCollatToAdd = abi.encode(
+                    Storage.OracleReadType.MORPHO_ORACLE,
+                    Storage.OracleReadType.MAX,
+                    readData,
+                    targetData,
+                    abi.encode(uint128(0), uint128(0.0005e18))
+                );
+            }
+
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGovernor.setOracle.selector,
+                    COLLATERAL_TO_ADD,
+                    oracleConfigCollatToAdd
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.togglePause.selector,
+                    COLLATERAL_TO_ADD,
+                    Storage.ActionType.Mint
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.togglePause.selector,
+                    COLLATERAL_TO_ADD,
+                    Storage.ActionType.Burn
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+            {
+                bytes memory data = abi.encodeWithSelector(
+                    ISettersGuardian.setStablecoinCap.selector,
+                    COLLATERAL_TO_ADD,
+                    capStablecoin
+                );
+                uint256 dataLength = data.length;
+                bytes memory internalTx = abi.encodePacked(isDelegateCall, to, value, dataLength, data);
+                transactions = abi.encodePacked(transactions, internalTx);
+            }
+        }
+
+        bytes memory payloadMultiSend = abi.encodeWithSelector(MultiSend.multiSend.selector, transactions);
+        address multiSend = address(_chainToMultiSend(chainId));
+        _serializeJson(
+            chainId,
+            multiSend,
+            0,
+            payloadMultiSend,
+            Enum.Operation.DelegateCall,
+            hex"",
+            _chainToContract(chainId, ContractType.GovernorMultisig)
+        );
+    }
+}