diff --git a/.gitmodules b/.gitmodules
index 32f4fc9..6cc88ab 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -16,4 +16,19 @@
 [submodule "lib/solidity-stringutils"]
 	path = lib/solidity-stringutils
 	url = https://github.com/Arachnid/solidity-stringutils
-	ignore = dirty
\ No newline at end of file
+	ignore = dirty
+[submodule "lib/angle-transmuter"]
+	path = lib/angle-transmuter
+	url = https://github.com/AngleProtocol/angle-transmuter
+[submodule "lib/borrow-contracts"]
+	path = lib/borrow-contracts
+	url = https://github.com/AngleProtocol/borrow-contracts
+[submodule "lib/new-oz"]
+	path = lib/new-oz
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "lib/new-oz-upgradeable"]
+	path = lib/new-oz-upgradeable
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
+[submodule "lib/chainlink"]
+	path = lib/chainlink
+	url = https://github.com/smartcontractkit/chainlink
diff --git a/foundry.toml b/foundry.toml
index e3a0c73..02a1d6f 100644
--- a/foundry.toml
+++ b/foundry.toml
@@ -12,6 +12,7 @@ optimizer = true
 optimizer_runs = 1000
 solc_version = "0.8.23"
 ffi = true
+fs_permissions = [{ access = "read-write", path = "./scripts/proposals/payload.json"}]
 
 [fuzz]
 runs = 10000
@@ -43,7 +44,7 @@ optimism = { key = "${OPTIMISM_ETHERSCAN_API_KEY}" }
 polygon = { key = "${POLYGON_ETHERSCAN_API_KEY}" }
 avalanche = { key = "${AVALANCHE_ETHERSCAN_API_KEY}" }
 celo = { key = "${CELO_ETHERSCAN_API_KEY}", url = "https://api.celoscan.io/api" }
-polygon-zkevm = { key = "${POLYGONZKEVM_ETHERSCAN_API_KEY}", url = "https://api-zkevm.polygonscan.com/api" }
+polygon-zkevm = { key = "${POLYGON_ZKEVM_ETHERSCAN_API_KEY}", url = "https://api-zkevm.polygonscan.com/api" }
 bsc = { key = "${BSC_ETHERSCAN_API_KEY}"}
 base = { key = "${BASE_ETHERSCAN_API_KEY}", url = "https://api.basescan.org/api" }
 linea = { key = "${LINEA_ETHERSCAN_API_KEY}" }
diff --git a/helpers/createProposal.sh b/helpers/createProposal.sh
new file mode 100644
index 0000000..0514ed2
--- /dev/null
+++ b/helpers/createProposal.sh
@@ -0,0 +1,197 @@
+#! /bin/bash
+
+function chain_to_uri {
+  chain=$1
+
+  case $chain in
+    "1")
+      echo $ETH_NODE_URI_MAINNET
+      ;;
+    "2")
+      echo $ETH_NODE_URI_ARBITRUM
+      ;;
+    "3")
+      echo $ETH_NODE_URI_POLYGON
+      ;;
+    "4")
+      echo $ETH_NODE_URI_GNOSIS
+      ;;
+    "5")
+      echo $ETH_NODE_URI_AVALANCHE
+      ;;
+    "6")
+      echo $ETH_NODE_URI_BASE
+      ;;
+    "7")
+        echo $ETH_NODE_URI_BSC
+        ;;
+    "8")
+        echo $ETH_NODE_URI_CELO
+        ;;
+    "9")
+        echo $ETH_NODE_URI_POLYGON_ZKEVM
+        ;;
+    "10")
+        echo $ETH_NODE_URI_OPTIMISM
+        ;;
+    "11")
+        echo $ETH_NODE_URI_LINEA
+        ;;
+    *)
+      ;;
+  esac
+}
+
+function chain_to_chainId {
+  chain=$1
+
+  case $chain in
+    "1")
+      echo "1"
+      ;;
+    "2")
+      echo "42161"
+      ;;
+    "3")
+      echo "137"
+      ;;
+    "4")
+      echo "100"
+      ;;
+    "5")
+      echo "43114"
+      ;;
+    "6")
+      echo "8453"
+      ;;
+    "7")
+        echo "56"
+        ;;
+    "8")
+        echo "42220"
+        ;;
+    "9")
+        echo "1101"
+        ;;
+    "10")
+        echo "10"
+        ;;
+    "11")
+        echo "59144"
+        ;;
+    *)
+      ;;
+  esac
+}
+
+function usage {
+  echo "bash createProposal.sh <script> <chain>"
+  echo ""
+  echo -e "script: path to the script to run"
+  echo -e "chain: chain(s) to run the script on (separate with commas)"
+  echo -e "\t1: Ethereum Mainnet"
+  echo -e "\t2: Arbitrum"
+  echo -e "\t3: Polygon"
+  echo -e "\t4: Gnosis"
+  echo -e "\t5: Avalanche"
+  echo -e "\t6: Base"
+  echo -e "\t7: Binance Smart Chain"
+  echo -e "\t8: Celo"
+  echo -e "\t9: Polygon ZkEvm"
+  echo -e "\t10: Optimism"
+  echo -e "\t11: Linea"
+  echo ""
+}
+
+function main {
+    command=false
+    if [[ $# -ne 2 && $# -ne 0 ]]; then
+        usage
+        exit 1
+    fi
+    if [ $# -eq 2 ]; then
+        script=$1
+        chains=$2
+        command=true
+    fi
+
+    if [ ! -f .env ]; then
+        echo ".env not found!"
+        exit 1
+    fi
+    source .env
+
+    if [ $command != true ]; then
+        echo ""
+        echo "What script would you like to run ?"
+
+        read script
+
+        if [ -z "$script" ]; then
+            echo "No script provided"
+            exit 1
+        fi
+
+        echo ""
+
+        echo "Which chain(s) would you like to run the script on ? (separate with commas)"
+        echo "- 1: Ethereum Mainnet"
+        echo "- 2: Arbitrum"
+        echo "- 3: Polygon"
+        echo "- 4: Gnosis"
+        echo "- 5: Avalanche"
+        echo "- 6: Base"
+        echo "- 7: Binance Smart Chain"
+        echo "- 8: Celo"
+        echo "- 9: Polygon ZkEvm"
+        echo "- 10: Optimism"
+        echo "- 11: Linea"
+
+        read chains
+
+        if [ -z "$chains" ]; then
+            echo "No chain provided"
+            exit 1
+        fi
+    fi
+
+    mainnet_uri=$(chain_to_uri 1)
+
+    chainIds=""
+    for chain in $(echo $chains | sed "s/,/ /g")
+    do
+        if [[ -z $chainIds ]]; then
+            chainIds="$(chain_to_chainId $chain)"
+        else
+            chainIds="$chainIds,$(chain_to_chainId $chain)"
+        fi
+    done
+
+    echo ""
+    echo "Running on chains $chainIds"
+
+    export CHAIN_IDS=$chainIds
+    # TODO if the script fails we should abort
+    FOUNDRY_PROFILE=dev forge script $script
+
+    if [ $? -ne 0 ]; then
+        echo ""
+        echo "Script failed"
+    fi
+
+    # TODO if the test fails we should abort
+    testContract="${script}Test"
+    echo ""
+    echo "Running test"
+    FOUNDRY_PROFILE=dev forge test --match-contract $testContract -vvv
+
+    echo ""
+    echo "Would you like to create the proposal ? (yes/no)"
+    read execute
+
+    # if [[ $execute == "yes" ]]; then
+    #     forge script scripts/interaction/Propose.s.sol:Propose --fork-url $mainnet_uri --broadcast
+    # fi
+}
+
+main $@
diff --git a/lib/angle-transmuter b/lib/angle-transmuter
new file mode 160000
index 0000000..7fd03d3
--- /dev/null
+++ b/lib/angle-transmuter
@@ -0,0 +1 @@
+Subproject commit 7fd03d3135c8d2ee8bcfe174b5b80c309823560f
diff --git a/lib/borrow-contracts b/lib/borrow-contracts
new file mode 160000
index 0000000..407a0e9
--- /dev/null
+++ b/lib/borrow-contracts
@@ -0,0 +1 @@
+Subproject commit 407a0e92653570e469bf1915ef3046e416e01582
diff --git a/lib/chainlink b/lib/chainlink
new file mode 160000
index 0000000..3cf93c9
--- /dev/null
+++ b/lib/chainlink
@@ -0,0 +1 @@
+Subproject commit 3cf93c9f849be99a451ddd77ac203395760302c2
diff --git a/lib/new-oz b/lib/new-oz
new file mode 160000
index 0000000..01ef448
--- /dev/null
+++ b/lib/new-oz
@@ -0,0 +1 @@
+Subproject commit 01ef448981be9d20ca85f2faf6ebdf591ce409f3
diff --git a/lib/new-oz-upgradeable b/lib/new-oz-upgradeable
new file mode 160000
index 0000000..fbdb824
--- /dev/null
+++ b/lib/new-oz-upgradeable
@@ -0,0 +1 @@
+Subproject commit fbdb824a735891908d5588b28e0da5852d7ed7ba
diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts
index 0b1b5f8..cffb2f1 160000
--- a/lib/openzeppelin-contracts
+++ b/lib/openzeppelin-contracts
@@ -1 +1 @@
-Subproject commit 0b1b5f89ef342b73e23e2fb6783d7a377478181f
+Subproject commit cffb2f1ddcd87efd68effc92cfd336c5145acabd
diff --git a/lib/openzeppelin-contracts-upgradeable b/lib/openzeppelin-contracts-upgradeable
index e10c70d..ebf264c 160000
--- a/lib/openzeppelin-contracts-upgradeable
+++ b/lib/openzeppelin-contracts-upgradeable
@@ -1 +1 @@
-Subproject commit e10c70d922c30c3cd09777b868cbd9a892bb57f8
+Subproject commit ebf264cc4b812e6557ed7d539e947211acd5670c
diff --git a/package.json b/package.json
index 76fc7fd..6dc45c7 100644
--- a/package.json
+++ b/package.json
@@ -7,8 +7,10 @@
     "coverage": "FOUNDRY_PROFILE=dev forge coverage --report lcov && yarn lcov:clean && yarn lcov:generate-html",
     "compile": "forge build",
     "compile:dev": "FOUNDRY_PROFILE=dev forge build",
-    "deploy": "forge script --skip test --broadcast --verify --slow -vvvv --rpc-url linea scripts/DeploySideChainGovernance.s.sol",
-    "deploy:fork": "forge script --skip test  --slow --fork-url fork --broadcast scripts/DeploySideChainGovernance.s.sol -vvvv",
+    "create:proposal": "bash helpers/createProposal.sh",
+    "deploy": "forge script --skip test --broadcast --verify --slow -vvvv --rpc-url polygon scripts/interaction/TimelockExecute.s.sol",
+    "deploy:test": "FOUNDRY_PROFILE=dev forge script --skip test --broadcast --verify --slow -vvvv --rpc-url gnosis scripts/DeployOnChainGovernance.s.sol",
+    "deploy:fork": "FOUNDRY_PROFILE=dev forge script --skip test  --slow --fork-url fork --broadcast scripts/interaction/TimelockExecute.s.sol -vvvv",
     "gas": "yarn test --gas-report",
     "fork": "bash helpers/fork.sh",
     "run": "docker run -it --rm -v $(pwd):/app -w /app ghcr.io/foundry-rs/foundry sh",
@@ -16,7 +18,7 @@
     "test:unit": "forge test -vvv --gas-report --match-path \"test/unit/**/*.sol\"",
     "test:invariant": "forge test -vvv --gas-report --match-path \"test/invariant/**/*.sol\"",
     "test:fuzz": "forge test -vvv --gas-report --match-path \"test/fuzz/**/*.sol\"",
-    "test": "FOUNDRY_PROFILE=dev forge test -vv",
+    "test": "FOUNDRY_PROFILE=dev forge test -vvvv",
     "slither": "slither .",
     "lcov:clean": "lcov --remove lcov.info -o lcov.info 'test/**' 'scripts/**' 'contracts/transmuter/configs/**' 'contracts/utils/**'",
     "lcov:generate-html": "genhtml lcov.info --output=coverage",
@@ -38,7 +40,7 @@
     "url": "https://github.com/AngleProtocol/boilerplate/issues"
   },
   "devDependencies": {
-    "@angleprotocol/sdk": "0.20.0",
+    "@angleprotocol/sdk": "^0.25.0",
     "@layerzerolabs/lz-sdk": "^0.0.30",
     "prettier": "^2.0.0",
     "prettier-plugin-solidity": "^1.1.3",
@@ -46,4 +48,4 @@
     "solhint-plugin-prettier": "^0.0.5"
   },
   "dependencies": {}
-}
+}
\ No newline at end of file
diff --git a/remappings.txt b/remappings.txt
index 73debcd..aa04ca4 100644
--- a/remappings.txt
+++ b/remappings.txt
@@ -1,6 +1,13 @@
 ds-test/=lib/forge-std/lib/ds-test/src/
 forge-std/=lib/forge-std/src/
-oz/=lib/openzeppelin-contracts/contracts/
-oz-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/
+oz/=lib/new-oz/contracts/
+oz-upgradeable/=lib/new-oz-upgradeable/contracts/
 lz/=lib/solidity-examples/contracts
-stringutils/=lib/solidity-stringutils
\ No newline at end of file
+stringutils/=lib/solidity-stringutils
+borrow/=lib/borrow-contracts/contracts
+transmuter/=lib/angle-transmuter/contracts
+contracts/=contracts
+test/=test
+@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts
+@chainlink/=lib/chainlink
\ No newline at end of file
diff --git a/scripts/BasicScript.s.sol b/scripts/BasicScript.s.sol
deleted file mode 100644
index e3e05ca..0000000
--- a/scripts/BasicScript.s.sol
+++ /dev/null
@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import "forge-std/Script.sol";
-import { console } from "forge-std/console.sol";
-
-contract MyScript is Script {
-    function test() external {
-        vm.startBroadcast();
-
-        address _sender = address(uint160(uint256(keccak256(abi.encodePacked("sender")))));
-        address _receiver = address(uint160(uint256(keccak256(abi.encodePacked("receiver")))));
-
-        vm.stopBroadcast();
-    }
-}
diff --git a/scripts/Constants.s.sol b/scripts/Constants.s.sol
index c35e414..b178774 100644
--- a/scripts/Constants.s.sol
+++ b/scripts/Constants.s.sol
@@ -4,6 +4,15 @@ pragma solidity ^0.8.9;
 
 import { ILayerZeroEndpoint } from "lz/lzApp/interfaces/ILayerZeroEndpoint.sol";
 import { IVotes } from "oz/governance/extensions/GovernorVotes.sol";
+import { ITransmuter } from "transmuter/interfaces/ITransmuter.sol";
+import { IAgToken } from "borrow/interfaces/IAgToken.sol";
+import { ProxyAdmin } from "oz/proxy/transparent/ProxyAdmin.sol";
+import { Ownable } from "oz/access/Ownable.sol";
+import { CoreBorrow } from "borrow/coreBorrow/CoreBorrow.sol";
+import { ITreasury } from "borrow/interfaces/ITreasury.sol";
+import { TimelockController } from "oz/governance/TimelockController.sol";
+import { AngleGovernor } from "contracts/AngleGovernor.sol";
+import "./Interfaces.s.sol";
 
 enum ContractType {
     Timelock,
@@ -27,6 +36,13 @@ enum ContractType {
     FeeDistributor
 }
 
+struct SubCall {
+    uint256 chainId;
+    address target;
+    uint256 value;
+    bytes data;
+}
+
 uint256 constant timelockDelay = 1 days;
 uint48 constant initialVotingDelay = 1 days;
 uint256 constant initialVotingDelayBlocks = 1 days / 12;
@@ -47,8 +63,20 @@ uint256 constant CHAIN_POLYGON = 137;
 uint256 constant CHAIN_GNOSIS = 100;
 uint256 constant CHAIN_BNB = 56;
 uint256 constant CHAIN_CELO = 42220;
-uint256 constant CHAIN_ZKEVMPOLYGON = 1101;
+uint256 constant CHAIN_POLYGONZKEVM = 1101;
 uint256 constant CHAIN_BASE = 8453;
 uint256 constant CHAIN_LINEA = 59144;
 uint256 constant CHAIN_MANTLE = 5000;
 uint256 constant CHAIN_AURORA = 1313161554;
+uint256 constant CHAIN_SOURCE = CHAIN_ETHEREUM;
+
+uint256 constant BASE_18 = 1e18;
+uint256 constant BASE_9 = 1e9;
+
+uint64 constant twoPoint5Rate = 782997666703977344;
+uint64 constant fourRate = 1243680713969297408;
+uint64 constant fourPoint3Rate = 1335019428339023872;
+
+string constant pathProposal = "/scripts/proposals/payload.json";
+address constant proposer = 0xfdA462548Ce04282f4B6D6619823a7C64Fdc0185;
+address constant whale = 0x41Bc7d0687e6Cea57Fa26da78379DfDC5627C56d;
diff --git a/scripts/Interfaces.s.sol b/scripts/Interfaces.s.sol
new file mode 100644
index 0000000..ab800ff
--- /dev/null
+++ b/scripts/Interfaces.s.sol
@@ -0,0 +1,59 @@
+pragma solidity ^0.8.19;
+
+interface IVaultManagerGovernance {
+    function setUint64(uint64 param, bytes32 what) external;
+
+    function interestRate() external view returns (uint64);
+}
+
+interface ISavings {
+    function setRate(uint208 newRate) external;
+
+    function rate() external view returns (uint208);
+}
+
+interface IAngle {
+    function setMinter(address minter) external;
+}
+
+interface IVeAngle {
+    function commit_transfer_ownership(address newAdmin) external;
+
+    function apply_transfer_ownership() external;
+}
+
+interface IGaugeController {
+    function commit_transfer_ownership(address newAdmin) external;
+
+    function apply_transfer_ownership() external;
+}
+
+interface ILiquidityGauge {
+    function commit_transfer_ownership(address newAdmin) external;
+
+    function apply_transfer_ownership() external;
+}
+
+interface IVeBoost {
+    function commit_transfer_ownership(address newAdmin) external;
+
+    function apply_transfer_ownership() external;
+}
+
+interface IVeBoostProxy {
+    function commit_admin(address newAdmin) external;
+
+    function apply_transfer_ownership() external;
+}
+
+interface ISmartWalletWhitelist {
+    function commitAdmin(address newAdmin) external;
+
+    function applyAdmin() external;
+}
+
+interface IFeeDistributor {
+    function commit_admin(address newAdmin) external;
+
+    function accept_admin() external;
+}
diff --git a/scripts/Utils.s.sol b/scripts/Utils.s.sol
index 3e0396b..69ad2c2 100644
--- a/scripts/Utils.s.sol
+++ b/scripts/Utils.s.sol
@@ -2,30 +2,67 @@
 pragma solidity ^0.8.19;
 
 import "forge-std/Script.sol";
-import "oz/proxy/transparent/ProxyAdmin.sol";
-import "oz/proxy/transparent/TransparentUpgradeableProxy.sol";
 import { AngleGovernor } from "contracts/AngleGovernor.sol";
 import { ProposalReceiver } from "contracts/ProposalReceiver.sol";
 import { ProposalSender } from "contracts/ProposalSender.sol";
 import { TimelockControllerWithCounter } from "contracts/TimelockControllerWithCounter.sol";
 import { ILayerZeroEndpoint } from "lz/lzApp/interfaces/ILayerZeroEndpoint.sol";
+import { ITreasury } from "borrow/interfaces/ITreasury.sol";
 import "./Constants.s.sol";
 
-import { console } from "forge-std/console.sol";
-
+/// @title Utils
+/// @author Angle Labs, Inc.
 contract Utils is Script {
-    //Update this address based on needs
-    address public constant PROXY_ADMIN = 0x1D941EF0D3Bba4ad67DBfBCeE5262F4CEE53A32b;
+    mapping(uint256 => uint256) internal forkIdentifier;
+    uint256 public arbitrumFork;
+    uint256 public avalancheFork;
+    uint256 public ethereumFork;
+    uint256 public optimismFork;
+    uint256 public polygonFork;
+    uint256 public gnosisFork;
+    uint256 public bnbFork;
+    uint256 public celoFork;
+    uint256 public polygonZkEVMFork;
+    uint256 public baseFork;
+    uint256 public lineaFork;
+
+    bytes[] private calldatas;
+    string private description;
+    address[] private targets;
+    uint256[] private values;
+    uint256[] private chainIds;
+
+    function setUp() public virtual {
+        arbitrumFork = vm.createFork(vm.envString("ETH_NODE_URI_ARBITRUM"));
+        avalancheFork = vm.createFork(vm.envString("ETH_NODE_URI_AVALANCHE"));
+        ethereumFork = vm.createFork(vm.envString("ETH_NODE_URI_MAINNET"));
+        optimismFork = vm.createFork(vm.envString("ETH_NODE_URI_OPTIMISM"));
+        polygonFork = vm.createFork(vm.envString("ETH_NODE_URI_POLYGON"));
+        gnosisFork = vm.createFork(vm.envString("ETH_NODE_URI_GNOSIS"));
+        bnbFork = vm.createFork(vm.envString("ETH_NODE_URI_BSC"));
+        celoFork = vm.createFork(vm.envString("ETH_NODE_URI_CELO"));
+        polygonZkEVMFork = vm.createFork(vm.envString("ETH_NODE_URI_POLYGON_ZKEVM"));
+        baseFork = vm.createFork(vm.envString("ETH_NODE_URI_BASE"));
+        lineaFork = vm.createFork(vm.envString("ETH_NODE_URI_LINEA"));
 
-    function deployUpgradeable(address implementation, bytes memory data) public returns (address) {
-        return address(new TransparentUpgradeableProxy(implementation, PROXY_ADMIN, data));
+        forkIdentifier[CHAIN_ARBITRUM] = arbitrumFork;
+        forkIdentifier[CHAIN_AVALANCHE] = avalancheFork;
+        forkIdentifier[CHAIN_ETHEREUM] = ethereumFork;
+        forkIdentifier[CHAIN_OPTIMISM] = optimismFork;
+        forkIdentifier[CHAIN_POLYGON] = polygonFork;
+        forkIdentifier[CHAIN_GNOSIS] = gnosisFork;
+        forkIdentifier[CHAIN_BNB] = bnbFork;
+        forkIdentifier[CHAIN_CELO] = celoFork;
+        forkIdentifier[CHAIN_POLYGONZKEVM] = polygonZkEVMFork;
+        forkIdentifier[CHAIN_BASE] = baseFork;
+        forkIdentifier[CHAIN_LINEA] = lineaFork;
     }
 
     function lzEndPoint(uint256 chainId) public returns (ILayerZeroEndpoint) {
         // TODO temporary check if LZ updated their sdk
         if (chainId == CHAIN_GNOSIS) {
             return ILayerZeroEndpoint(0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4);
-        } else if (chainId == CHAIN_ZKEVMPOLYGON) {
+        } else if (chainId == CHAIN_POLYGONZKEVM) {
             return ILayerZeroEndpoint(0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4);
         } else if (chainId == CHAIN_BASE) {
             return ILayerZeroEndpoint(0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7);
@@ -55,12 +92,12 @@ contract Utils is Script {
         else if (name == ContractType.ProposalReceiver) cmd[3] = "proposalReceiver";
         else if (name == ContractType.ProposalSender) cmd[3] = "proposalSender";
         else if (name == ContractType.Governor) cmd[3] = "governor";
-        else if (name == ContractType.GuardianMultisig) cmd[3] = "guardian";
         else if (name == ContractType.TreasuryAgEUR) cmd[3] = "treasury";
         else if (name == ContractType.StEUR) cmd[3] = "stEUR";
         else if (name == ContractType.TransmuterAgEUR) cmd[3] = "transmuterAgEUR";
         else if (name == ContractType.CoreBorrow) cmd[3] = "coreBorrow";
         else if (name == ContractType.GovernorMultisig) cmd[3] = "governorMultisig";
+        else if (name == ContractType.GuardianMultisig) cmd[3] = "guardian";
         else if (name == ContractType.ProxyAdmin) cmd[3] = "proxyAdmin";
         else if (name == ContractType.Angle) cmd[3] = "angle";
         else if (name == ContractType.veANGLE) cmd[3] = "veANGLE";
@@ -100,4 +137,168 @@ contract Utils is Script {
         if (res.length == 0) revert("Chain not supported");
         return uint16(stringToUint(string(res)));
     }
+
+    function _deserializeJson()
+        internal
+        returns (bytes[] memory, string memory, address[] memory, uint256[] memory, uint256[] memory)
+    {
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, pathProposal);
+        string memory json = vm.readFile(path);
+
+        bytes memory encodedStruct = vm.parseJson(json, ".description");
+        description = abi.decode(encodedStruct, (string));
+        {
+            string memory calldataKey = ".calldatas";
+            string[] memory keys = vm.parseJsonKeys(json, calldataKey);
+            // Iterate over the encoded structs
+            for (uint256 i = 0; i < keys.length; ++i) {
+                string memory structKey = string.concat(calldataKey, ".", keys[i]);
+                bytes memory encodedStruct = vm.parseJson(json, structKey);
+                calldatas.push(abi.decode(encodedStruct, (bytes)));
+            }
+        }
+        {
+            string memory targetsKey = ".targets";
+            string[] memory keys = vm.parseJsonKeys(json, targetsKey);
+            // Iterate over the encoded structs
+            for (uint256 i = 0; i < keys.length; ++i) {
+                string memory structKey = string.concat(targetsKey, ".", keys[i]);
+                bytes memory encodedStruct = vm.parseJson(json, structKey);
+                targets.push(abi.decode(encodedStruct, (address)));
+            }
+        }
+        {
+            string memory valuesKey = ".values";
+            string[] memory keys = vm.parseJsonKeys(json, valuesKey);
+            // Iterate over the encoded structs
+            for (uint256 i = 0; i < keys.length; ++i) {
+                string memory structKey = string.concat(valuesKey, ".", keys[i]);
+                bytes memory encodedStruct = vm.parseJson(json, structKey);
+                values.push(abi.decode(encodedStruct, (uint256)));
+            }
+        }
+        {
+            string memory chainIdsKey = ".chainIds";
+            string[] memory keys = vm.parseJsonKeys(json, chainIdsKey);
+            // Iterate over the encoded structs
+            for (uint256 i = 0; i < keys.length; ++i) {
+                string memory structKey = string.concat(chainIdsKey, ".", keys[i]);
+                bytes memory encodedStruct = vm.parseJson(json, structKey);
+                chainIds.push(abi.decode(encodedStruct, (uint256)));
+            }
+        }
+        return (calldatas, description, targets, values, chainIds);
+    }
+
+    function _serializeJson(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        uint256[] memory chainIds,
+        string memory description
+    ) internal {
+        string memory json = "chain";
+
+        {
+            string memory jsonTargets = "targets";
+            string memory targetsOutput;
+            for (uint256 i; i < targets.length; i++) {
+                targetsOutput = vm.serializeAddress(jsonTargets, vm.toString(i), targets[i]);
+            }
+            vm.serializeString(json, "targets", targetsOutput);
+        }
+        {
+            string memory jsonValues = "values";
+            string memory valuesOutput;
+            for (uint256 i; i < values.length; i++) {
+                valuesOutput = vm.serializeUint(jsonValues, vm.toString(i), values[i]);
+            }
+            vm.serializeString(json, "values", valuesOutput);
+        }
+        {
+            string memory jsonCalldatas = "calldatas";
+            string memory calldatasOutput;
+            for (uint256 i; i < calldatas.length; i++) {
+                calldatasOutput = vm.serializeBytes(jsonCalldatas, vm.toString(i), calldatas[i]);
+            }
+            vm.serializeString(json, "calldatas", calldatasOutput);
+        }
+        {
+            string memory jsonChainIds = "chainIds";
+            string memory chainIdsOutput;
+            for (uint256 i; i < chainIds.length; i++) {
+                chainIdsOutput = vm.serializeUint(jsonChainIds, vm.toString(i), chainIds[i]);
+            }
+            vm.serializeString(json, "chainIds", chainIdsOutput);
+        }
+        string memory output = vm.serializeString(json, "description", description);
+
+        string memory root = vm.projectRoot();
+        string memory path = string.concat(root, pathProposal);
+        vm.writeJson(output, path);
+    }
+
+    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
+        require(_length + 31 >= _length, "slice_overflow");
+        require(_bytes.length >= _start + _length, "slice_outOfBounds");
+
+        bytes memory tempBytes;
+
+        // Check length is 0. `iszero` return 1 for `true` and 0 for `false`.
+        assembly {
+            switch iszero(_length)
+            case 0 {
+                // Get a location of some free memory and store it in tempBytes as
+                // Solidity does for memory variables.
+                tempBytes := mload(0x40)
+
+                // Calculate length mod 32 to handle slices that are not a multiple of 32 in size.
+                let lengthmod := and(_length, 31)
+
+                // tempBytes will have the following format in memory: <length><data>
+                // When copying data we will offset the start forward to avoid allocating additional memory
+                // Therefore part of the length area will be written, but this will be overwritten later anyways.
+                // In case no offset is require, the start is set to the data region (0x20 from the tempBytes)
+                // mc will be used to keep track where to copy the data to.
+                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
+                let end := add(mc, _length)
+
+                for {
+                    // Same logic as for mc is applied and additionally the start offset specified for the method is added
+                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
+                } lt(mc, end) {
+                    // increase `mc` and `cc` to read the next word from memory
+                    mc := add(mc, 0x20)
+                    cc := add(cc, 0x20)
+                } {
+                    // Copy the data from source (cc location) to the slice data (mc location)
+                    mstore(mc, mload(cc))
+                }
+
+                // Store the length of the slice. This will overwrite any partial data that
+                // was copied when having slices that are not a multiple of 32.
+                mstore(tempBytes, _length)
+
+                // update free-memory pointer
+                // allocating the array padded to 32 bytes like the compiler does now
+                // To set the used memory as a multiple of 32, add 31 to the actual memory usage (mc)
+                // and remove the modulo 32 (the `and` with `not(31)`)
+                mstore(0x40, and(add(mc, 31), not(31)))
+            }
+            // if we want a zero-length slice let's just return a zero-length array
+            default {
+                tempBytes := mload(0x40)
+                // zero out the 32 bytes slice we are about to return
+                // we need to do it because Solidity does not garbage collect
+                mstore(tempBytes, 0)
+
+                // update free-memory pointer
+                // tempBytes uses 32 bytes in memory (even when empty) for the length.
+                mstore(0x40, add(tempBytes, 0x20))
+            }
+        }
+
+        return tempBytes;
+    }
 }
diff --git a/scripts/DeployOnChainGovernance.s.sol b/scripts/deployment/DeployOnChainGovernance.s.sol
similarity index 95%
rename from scripts/DeployOnChainGovernance.s.sol
rename to scripts/deployment/DeployOnChainGovernance.s.sol
index d359c2a..8cca756 100644
--- a/scripts/DeployOnChainGovernance.s.sol
+++ b/scripts/deployment/DeployOnChainGovernance.s.sol
@@ -4,14 +4,14 @@ pragma solidity ^0.8.19;
 import { console } from "forge-std/console.sol";
 import { stdJson } from "forge-std/StdJson.sol";
 import "stringutils/strings.sol";
-import "./Utils.s.sol";
+import "../Utils.s.sol";
 import "oz/interfaces/IERC20.sol";
 
 import { IveANGLEVotingDelegation } from "contracts/interfaces/IveANGLEVotingDelegation.sol";
-import { deployMockANGLE, deployVeANGLE } from "./test/DeployANGLE.s.sol";
+import { deployMockANGLE, deployVeANGLE } from "../test/DeployANGLE.s.sol";
 import { ERC20 } from "oz/token/ERC20/ERC20.sol";
 import "contracts/interfaces/IveANGLE.sol";
-import "../test/external/VyperDeployer.sol";
+import "../../test/external/VyperDeployer.sol";
 
 import { AngleGovernor } from "contracts/AngleGovernor.sol";
 import { ProposalReceiver } from "contracts/ProposalReceiver.sol";
diff --git a/scripts/DeploySideChainGovernance.s.sol b/scripts/deployment/DeploySideChainGovernance.s.sol
similarity index 99%
rename from scripts/DeploySideChainGovernance.s.sol
rename to scripts/deployment/DeploySideChainGovernance.s.sol
index 0b434f3..510baad 100644
--- a/scripts/DeploySideChainGovernance.s.sol
+++ b/scripts/deployment/DeploySideChainGovernance.s.sol
@@ -4,7 +4,7 @@ pragma solidity ^0.8.19;
 import { console } from "forge-std/console.sol";
 import { stdJson } from "forge-std/StdJson.sol";
 import "stringutils/strings.sol";
-import "./Utils.s.sol";
+import "../Utils.s.sol";
 import "oz/interfaces/IERC20.sol";
 
 import { TimelockControllerWithCounter } from "contracts/TimelockControllerWithCounter.sol";
diff --git a/scripts/interaction/CrossChainProposal.s.sol b/scripts/interaction/CrossChainProposal.s.sol
index fead025..b4e23c7 100644
--- a/scripts/interaction/CrossChainProposal.s.sol
+++ b/scripts/interaction/CrossChainProposal.s.sol
@@ -75,8 +75,8 @@ contract CrossChainProposal is Utils {
             abi.encodePacked(uint16(1), uint256(300000))
         );
 
-        // uint256 proposalId = governor.propose(targets, values, calldatas, description);
-        uint256 proposalId = 0x7f3a7bfba6ab7cdc0f85cfaa8bc2b03178c4d28dabbf53a1908604d2cb2d6891;
+        uint256 proposalId = governor.propose(targets, values, calldatas, description);
+        // uint256 proposalId = 0x7f3a7bfba6ab7cdc0f85cfaa8bc2b03178c4d28dabbf53a1908604d2cb2d6891;
         governor.castVote(proposalId, 1);
 
         governor.execute{ value: feeLZ }(targets, values, calldatas, keccak256(bytes(description)));
diff --git a/scripts/interaction/Helpers.s.sol b/scripts/interaction/Helpers.s.sol
deleted file mode 100644
index cd11eff..0000000
--- a/scripts/interaction/Helpers.s.sol
+++ /dev/null
@@ -1,210 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.19;
-
-// import { console } from "forge-std/console.sol";
-// import { stdJson } from "forge-std/StdJson.sol";
-// import "stringutils/strings.sol";
-// import "../Utils.s.sol";
-// import { SubCall } from "../../test/unit/Proposal.sol";
-// import "oz/interfaces/IERC20.sol";
-
-// import { IveANGLEVotingDelegation } from "contracts/interfaces/IveANGLEVotingDelegation.sol";
-// import { ERC20 } from "oz/token/ERC20/ERC20.sol";
-// import "contracts/interfaces/IveANGLE.sol";
-
-// import { AngleGovernor } from "contracts/AngleGovernor.sol";
-// import { ProposalReceiver } from "contracts/ProposalReceiver.sol";
-// import { ProposalSender } from "contracts/ProposalSender.sol";
-// import { TimelockControllerWithCounter } from "contracts/TimelockControllerWithCounter.sol";
-// import { VeANGLEVotingDelegation, ECDSA } from "contracts/VeANGLEVotingDelegation.sol";
-
-// /// @dev To deploy on a different chain, just replace the import of the `Constants.s.sol` file by a file which has the
-// /// constants defined for the chain of your choice.
-// contract Helpers is Utils {
-//     using stdJson for string;
-//     using strings for *;
-
-//     /// @notice Build the governor proposal based on all the transaction that need to be executed
-//     function _wrap(
-//         SubCall[] memory prop
-//     ) internal returns (address[] memory targets, uint256[] memory values, bytes[] memory calldatas) {
-//         targets = new address[](prop.length);
-//         values = new uint256[](prop.length);
-//         calldatas = new bytes[](prop.length);
-//         uint256 finalPropLength;
-//         uint256 i;
-//         while (i < prop.length) {
-//             uint256 chainId = prop[i].chainId;
-//             // Check the number of same chainId actions
-//             uint256 count = 1;
-//             while (i + count < prop.length && prop[i + count].chainId == chainId) {
-//                 count++;
-//             }
-
-//             // Check that the chainId are consecutives
-//             for (uint256 j = i + count; j < prop.length; j++) {
-//                 if (prop[j].chainId == chainId) {
-//                     revert("Invalid proposal, chainId must be gathered");
-//                 }
-//             }
-
-//             if (chainId == 1) {
-//                 vm.selectFork(forkIdentifier[1]);
-
-//                 (
-//                     address[] memory batchTargets,
-//                     uint256[] memory batchValues,
-//                     bytes[] memory batchCalldatas
-//                 ) = filterChainSubCalls(chainId, prop);
-//                 (targets[finalPropLength], values[finalPropLength], calldatas[finalPropLength]) = wrapTimelock(
-//                     chainId,
-//                     prop
-//                 );
-//                 finalPropLength += 1;
-//                 i += count;
-//             } else {
-//                 vm.selectFork(forkIdentifier[chainId]);
-
-//                 (
-//                     address[] memory batchTargets,
-//                     uint256[] memory batchValues,
-//                     bytes[] memory batchCalldatas
-//                 ) = filterChainSubCalls(chainId, prop);
-//                 (address target, uint256 value, bytes memory data) = wrapTimelock(chainId, prop);
-
-//                 batchTargets = new address[](1);
-//                 batchTargets[0] = target;
-//                 batchValues = new uint256[](1);
-//                 batchValues[0] = value;
-//                 batchCalldatas = new bytes[](1);
-//                 batchCalldatas[0] = data;
-
-//                 // Wrap for proposal sender
-//                 targets[finalPropLength] = address(proposalSender());
-//                 values[finalPropLength] = 0.1 ether;
-//                 calldatas[finalPropLength] = abi.encodeWithSelector(
-//                     proposalSender().execute.selector,
-//                     getLZChainId(chainId),
-//                     abi.encode(batchTargets, batchValues, new string[](1), batchCalldatas),
-//                     abi.encodePacked(uint16(1), uint256(300000))
-//                 );
-//                 finalPropLength += 1;
-//                 i += count;
-//             }
-//         }
-//         assembly ("memory-safe") {
-//             mstore(targets, finalPropLength)
-//             mstore(values, finalPropLength)
-//             mstore(calldatas, finalPropLength)
-//         }
-//         vm.selectFork(forkIdentifier[1]); // Set back the fork to mainnet
-//     }
-
-//     function filterChainSubCalls(
-//         uint256 chainId,
-//         SubCall[] memory prop
-//     )
-//         internal
-//         pure
-//         returns (address[] memory batchTargets, uint256[] memory batchValues, bytes[] memory batchCalldatas)
-//     {
-//         uint256 count;
-//         batchTargets = new address[](prop.length);
-//         batchValues = new uint256[](prop.length);
-//         batchCalldatas = new bytes[](prop.length);
-//         for (uint256 j; j < prop.length; j++) {
-//             if (prop[j].chainId == chainId) {
-//                 batchTargets[count] = prop[j].target;
-//                 batchValues[count] = prop[j].value;
-//                 batchCalldatas[count] = prop[j].data;
-//                 count++;
-//             }
-//         }
-
-//         assembly ("memory-safe") {
-//             mstore(batchTargets, count)
-//             mstore(batchValues, count)
-//             mstore(batchCalldatas, count)
-//         }
-//     }
-
-//     function wrapTimelock(
-//         uint256 chainId,
-//         SubCall[] memory p
-//     ) public view returns (address target, uint256 value, bytes memory data) {
-//         (
-//             address[] memory batchTargets,
-//             uint256[] memory batchValues,
-//             bytes[] memory batchCalldatas
-//         ) = filterChainSubCalls(chainId, p);
-//         if (batchTargets.length == 1) {
-//             // In case the operation has already been done add a salt
-//             uint256 salt = computeSalt(chainId, p);
-//             // Simple schedule on timelock
-//             target = address(timelock(chainId));
-//             value = 0;
-//             data = abi.encodeWithSelector(
-//                 timelock(chainId).schedule.selector,
-//                 batchTargets[0],
-//                 batchValues[0],
-//                 batchCalldatas[0],
-//                 bytes32(0),
-//                 salt,
-//                 timelock(chainId).getMinDelay()
-//             );
-//         } else {
-//             // In case the operation has already been done add a salt
-//             uint256 salt = computeSalt(chainId, p);
-//             target = address(timelock(chainId));
-//             value = 0;
-//             data = abi.encodeWithSelector(
-//                 timelock(chainId).scheduleBatch.selector,
-//                 batchTargets,
-//                 batchValues,
-//                 batchCalldatas,
-//                 bytes32(0),
-//                 salt,
-//                 timelock(chainId).getMinDelay()
-//             );
-//         }
-//     }
-
-//     function computeSalt(uint256 chainId, SubCall[] memory p) internal view returns (uint256 salt) {
-//         (
-//             address[] memory batchTargets,
-//             uint256[] memory batchValues,
-//             bytes[] memory batchCalldatas
-//         ) = filterChainSubCalls(chainId, p);
-//         if (batchTargets.length == 1) {
-//             salt = 0;
-//             while (
-//                 timelock(chainId).isOperation(
-//                     timelock(chainId).hashOperation(
-//                         batchTargets[0],
-//                         batchValues[0],
-//                         batchCalldatas[0],
-//                         bytes32(0),
-//                         bytes32(salt)
-//                     )
-//                 )
-//             ) {
-//                 salt++;
-//             }
-//         } else {
-//             salt = 0;
-//             while (
-//                 timelock(chainId).isOperation(
-//                     timelock(chainId).hashOperationBatch(
-//                         batchTargets,
-//                         batchValues,
-//                         batchCalldatas,
-//                         bytes32(0),
-//                         bytes32(salt)
-//                     )
-//                 )
-//             ) {
-//                 salt++;
-//             }
-//         }
-//     }
-// }
diff --git a/scripts/interaction/ProposalReceiverConnect.s.sol b/scripts/interaction/ProposalReceiverConnect.s.sol
index e8a065a..10bae32 100644
--- a/scripts/interaction/ProposalReceiverConnect.s.sol
+++ b/scripts/interaction/ProposalReceiverConnect.s.sol
@@ -39,8 +39,8 @@ contract ProposalReceiverConnect is Utils {
         );
 
         // uint256 proposalId = governor.propose(targets, values, calldatas, description);
-
         uint256 proposalId = 0x5af180d896738e85d65edfa0f75944289b65485e86ee38fd0776e140a89634d4;
+
         governor.castVote(proposalId, 1);
 
         governor.execute(targets, values, calldatas, keccak256(bytes(description)));
diff --git a/scripts/proposals/Propose.s.sol b/scripts/proposals/Propose.s.sol
new file mode 100644
index 0000000..d4cd89c
--- /dev/null
+++ b/scripts/proposals/Propose.s.sol
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.19;
+
+import { console } from "forge-std/console.sol";
+import "../Utils.s.sol";
+import { stdJson } from "forge-std/StdJson.sol";
+import { AngleGovernor } from "contracts/AngleGovernor.sol";
+
+struct Proposal {
+    bytes[] calldatas;
+    string description;
+    address[] targets;
+    uint256[] values;
+}
+
+contract Propose is Utils {
+    using stdJson for string;
+
+    function setUp() public virtual override {}
+
+    function run() external {
+        (
+            bytes[] memory calldatas,
+            string memory description,
+            address[] memory targets,
+            uint256[] memory values,
+            uint256[] memory chainIds
+        ) = _deserializeJson();
+
+        uint256 deployerPrivateKey = vm.deriveKey(vm.envString("MNEMONIC_MAINNET"), 0);
+        vm.rememberKey(deployerPrivateKey);
+
+        vm.startBroadcast(deployerPrivateKey);
+        AngleGovernor governor = AngleGovernor(payable(_chainToContract(CHAIN_ETHEREUM, ContractType.Governor)));
+        uint256 proposalId = governor.propose(targets, values, calldatas, description);
+        console.log("Proposal id: %d", proposalId);
+
+        vm.stopBroadcast();
+    }
+}
diff --git a/scripts/proposals/Wrapper.s.sol b/scripts/proposals/Wrapper.s.sol
new file mode 100644
index 0000000..6e42618
--- /dev/null
+++ b/scripts/proposals/Wrapper.s.sol
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.20;
+
+import "../Utils.s.sol";
+
+contract Wrapper is Utils {
+    function wrapTimelock(
+        uint256 chainId,
+        SubCall[] memory p
+    ) public returns (address target, uint256 value, bytes memory data) {
+        TimelockControllerWithCounter timelock = TimelockControllerWithCounter(
+            payable(_chainToContract(chainId, ContractType.Timelock))
+        );
+        (
+            address[] memory batchTargets,
+            uint256[] memory batchValues,
+            bytes[] memory batchCalldatas
+        ) = filterChainSubCalls(chainId, p);
+        if (batchTargets.length == 1) {
+            // In case the operation has already been done add a salt
+            uint256 salt = computeSalt(chainId, p);
+            // Simple schedule on timelock
+            target = address(timelock);
+            value = 0;
+            data = abi.encodeWithSelector(
+                timelock.schedule.selector,
+                batchTargets[0],
+                batchValues[0],
+                batchCalldatas[0],
+                bytes32(0),
+                salt,
+                timelock.getMinDelay()
+            );
+        } else {
+            // In case the operation has already been done add a salt
+            uint256 salt = computeSalt(chainId, p);
+            target = address(timelock);
+            value = 0;
+            data = abi.encodeWithSelector(
+                timelock.scheduleBatch.selector,
+                batchTargets,
+                batchValues,
+                batchCalldatas,
+                bytes32(0),
+                salt,
+                timelock.getMinDelay()
+            );
+        }
+    }
+
+    function computeSalt(uint256 chainId, SubCall[] memory p) internal returns (uint256 salt) {
+        TimelockControllerWithCounter timelock = TimelockControllerWithCounter(
+            payable(_chainToContract(chainId, ContractType.Timelock))
+        );
+        (
+            address[] memory batchTargets,
+            uint256[] memory batchValues,
+            bytes[] memory batchCalldatas
+        ) = filterChainSubCalls(chainId, p);
+        if (batchTargets.length == 1) {
+            salt = 0;
+            while (
+                timelock.isOperation(
+                    timelock.hashOperation(
+                        batchTargets[0],
+                        batchValues[0],
+                        batchCalldatas[0],
+                        bytes32(0),
+                        bytes32(salt)
+                    )
+                )
+            ) {
+                salt++;
+            }
+        } else {
+            salt = 0;
+            while (
+                timelock.isOperation(
+                    timelock.hashOperationBatch(batchTargets, batchValues, batchCalldatas, bytes32(0), bytes32(salt))
+                )
+            ) {
+                salt++;
+            }
+        }
+    }
+
+    function filterChainSubCalls(
+        uint256 chainId,
+        SubCall[] memory prop
+    )
+        internal
+        pure
+        returns (address[] memory batchTargets, uint256[] memory batchValues, bytes[] memory batchCalldatas)
+    {
+        uint256 count;
+        batchTargets = new address[](prop.length);
+        batchValues = new uint256[](prop.length);
+        batchCalldatas = new bytes[](prop.length);
+        for (uint256 j; j < prop.length; j++) {
+            if (prop[j].chainId == chainId) {
+                batchTargets[count] = prop[j].target;
+                batchValues[count] = prop[j].value;
+                batchCalldatas[count] = prop[j].data;
+                count++;
+            }
+        }
+
+        assembly ("memory-safe") {
+            mstore(batchTargets, count)
+            mstore(batchValues, count)
+            mstore(batchCalldatas, count)
+        }
+    }
+
+    function _wrap(
+        SubCall[] memory prop
+    )
+        internal
+        returns (address[] memory targets, uint256[] memory values, bytes[] memory calldatas, uint256[] memory chainIds)
+    {
+        targets = new address[](prop.length);
+        values = new uint256[](prop.length);
+        calldatas = new bytes[](prop.length);
+        chainIds = new uint256[](prop.length);
+
+        uint256 finalPropLength;
+        uint256 i;
+        while (i < prop.length) {
+            uint256 chainId = prop[i].chainId;
+            // Check the number of same chainId actions
+            uint256 count = 1;
+            while (i + count < prop.length && prop[i + count].chainId == chainId) {
+                count++;
+            }
+
+            // Check that the chainId are consecutives
+            for (uint256 j = i + count; j < prop.length; j++) {
+                if (prop[j].chainId == chainId) {
+                    revert("Invalid proposal, chainId must be gathered");
+                }
+            }
+
+            if (chainId == CHAIN_SOURCE) {
+                vm.selectFork(forkIdentifier[1]);
+                (targets[finalPropLength], values[finalPropLength], calldatas[finalPropLength]) = wrapTimelock(
+                    chainId,
+                    prop
+                );
+                chainIds[finalPropLength] = chainId;
+                finalPropLength += 1;
+                i += count;
+            } else {
+                vm.selectFork(forkIdentifier[chainId]);
+                (address target, uint256 value, bytes memory data) = wrapTimelock(chainId, prop);
+
+                address[] memory batchTargets = new address[](1);
+                batchTargets[0] = target;
+                uint256[] memory batchValues = new uint256[](1);
+                batchValues[0] = value;
+                bytes[] memory batchCalldatas = new bytes[](1);
+                batchCalldatas[0] = data;
+
+                // Wrap for proposal sender
+                ProposalSender proposalSender = ProposalSender(
+                    _chainToContract(CHAIN_SOURCE, ContractType.ProposalSender)
+                );
+                targets[finalPropLength] = address(proposalSender);
+                values[finalPropLength] = 0.1 ether;
+                chainIds[finalPropLength] = chainId;
+                calldatas[finalPropLength] = abi.encodeWithSelector(
+                    ProposalSender.execute.selector,
+                    getLZChainId(chainId),
+                    abi.encode(batchTargets, batchValues, new string[](1), batchCalldatas),
+                    abi.encodePacked(uint16(1), uint256(300000))
+                );
+                finalPropLength += 1;
+                i += count;
+            }
+        }
+        assembly ("memory-safe") {
+            mstore(targets, finalPropLength)
+            mstore(values, finalPropLength)
+            mstore(calldatas, finalPropLength)
+        }
+    }
+}
diff --git a/scripts/proposals/payload.json b/scripts/proposals/payload.json
new file mode 100644
index 0000000..f71453b
--- /dev/null
+++ b/scripts/proposals/payload.json
@@ -0,0 +1,31 @@
+{
+  "calldatas": {
+    "0": "0xbb5a944f0000000000000000000000000000000000000000000000000000000000000066000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000003800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000c9025cef778a8032a689ac52798c66939c17c22f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000012401d5062a000000000000000000000000c9025cef778a8032a689ac52798c66939c17c22f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000002464d623530000000000000000000000000000000000000000000000000000000000093a8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022000100000000000000000000000000000000000000000000000000000000000493e0000000000000000000000000000000000000000000000000000000000000",
+    "1": "0xbb5a944f000000000000000000000000000000000000000000000000000000000000006e000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000003800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000169487a55de79476125a56b07c36ca8dbf37a3730000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000012401d5062a000000000000000000000000169487a55de79476125a56b07c36ca8dbf37a373000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000002464d623530000000000000000000000000000000000000000000000000000000000093a8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022000100000000000000000000000000000000000000000000000000000000000493e0000000000000000000000000000000000000000000000000000000000000",
+    "2": "0xbb5a944f000000000000000000000000000000000000000000000000000000000000009e000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000003800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000c1f9266c6d3389e981639ee873121199a7acdb8f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000012401d5062a000000000000000000000000c1f9266c6d3389e981639ee873121199a7acdb8f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000002464d623530000000000000000000000000000000000000000000000000000000000093a8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022000100000000000000000000000000000000000000000000000000000000000493e0000000000000000000000000000000000000000000000000000000000000",
+    "3": "0xbb5a944f000000000000000000000000000000000000000000000000000000000000006f000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000003800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000343902fe4d72e24b29f22d787b2e54eeea5e82270000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000012401d5062a000000000000000000000000343902fe4d72e24b29f22d787b2e54eeea5e8227000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000002464d623530000000000000000000000000000000000000000000000000000000000093a8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022000100000000000000000000000000000000000000000000000000000000000493e0000000000000000000000000000000000000000000000000000000000000",
+    "4": "0xbb5a944f0000000000000000000000000000000000000000000000000000000000000091000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000003800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000b2ea590fcea142dcceaeb3912da4c1df721848ef0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000012401d5062a000000000000000000000000b2ea590fcea142dcceaeb3912da4c1df721848ef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000002464d623530000000000000000000000000000000000000000000000000000000000093a8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022000100000000000000000000000000000000000000000000000000000000000493e0000000000000000000000000000000000000000000000000000000000000"
+  },
+  "chainIds": {
+    "0": 56,
+    "1": 42161,
+    "2": 1101,
+    "3": 10,
+    "4": 100
+  },
+  "description": "Set min delay for timelock",
+  "targets": {
+    "0": "0x896D64B4B7265273dDCD00808f3579563f9790A8",
+    "1": "0x896D64B4B7265273dDCD00808f3579563f9790A8",
+    "2": "0x896D64B4B7265273dDCD00808f3579563f9790A8",
+    "3": "0x896D64B4B7265273dDCD00808f3579563f9790A8",
+    "4": "0x896D64B4B7265273dDCD00808f3579563f9790A8"
+  },
+  "values": {
+    "0": 100000000000000000,
+    "1": 100000000000000000,
+    "2": 100000000000000000,
+    "3": 100000000000000000,
+    "4": 100000000000000000
+  }
+}
\ No newline at end of file
diff --git a/scripts/proposals/savings/SavingsSetRate.s.sol b/scripts/proposals/savings/SavingsSetRate.s.sol
new file mode 100644
index 0000000..f71c36b
--- /dev/null
+++ b/scripts/proposals/savings/SavingsSetRate.s.sol
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.20;
+
+import { console } from "forge-std/console.sol";
+import { Wrapper } from "../Wrapper.s.sol";
+import "../../Constants.s.sol";
+
+contract SavingsSetRate is Wrapper {
+    SubCall[] private subCalls;
+
+    function _setRateSavings(uint256 chainId, uint208 rate) private {
+        vm.selectFork(forkIdentifier[chainId]);
+        address stEUR = _chainToContract(chainId, ContractType.StEUR);
+
+        subCalls.push(SubCall(chainId, stEUR, 0, abi.encodeWithSelector(ISavings.setRate.selector, rate)));
+    }
+
+    function run() external {
+        uint256[] memory chainIds = vm.envUint("CHAIN_IDS", ",");
+        string memory description = "Set rate for all savings";
+
+        /** TODO  complete */
+        uint208 rate = uint208(uint256(fourPoint3Rate));
+        /** END  complete */
+
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            _setRateSavings(chainIds[i], rate);
+        }
+
+        (
+            address[] memory targets,
+            uint256[] memory values,
+            bytes[] memory calldatas,
+            uint256[] memory chainIds2
+        ) = _wrap(subCalls);
+        _serializeJson(targets, values, calldatas, chainIds2, description);
+    }
+}
diff --git a/scripts/proposals/timelock/SetMinDelayTimelock.s.sol b/scripts/proposals/timelock/SetMinDelayTimelock.s.sol
new file mode 100644
index 0000000..30c4f8f
--- /dev/null
+++ b/scripts/proposals/timelock/SetMinDelayTimelock.s.sol
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.20;
+
+import { console } from "forge-std/console.sol";
+import { IVaultManagerFunctions } from "borrow/interfaces/IVaultManager.sol";
+import { IERC721Metadata } from "oz/token/ERC721/extensions/IERC721Metadata.sol";
+
+import { Wrapper } from "../Wrapper.s.sol";
+import "../../Constants.s.sol";
+
+contract SetMinDelayTimelock is Wrapper {
+    SubCall[] private subCalls;
+
+    function _setMinDelay(uint256 chainId, uint256 minDelay) private {
+        vm.selectFork(forkIdentifier[chainId]);
+        address timelock = _chainToContract(chainId, ContractType.Timelock);
+
+        subCalls.push(
+            SubCall(chainId, timelock, 0, abi.encodeWithSelector(TimelockController.updateDelay.selector, minDelay))
+        );
+    }
+
+    function run() external {
+        uint256[] memory chainIds = vm.envUint("CHAIN_IDS", ",");
+        string memory description = "Set min delay for timelock";
+
+        /** TODO  complete */
+        uint256 minDelay = uint256(1 weeks);
+        /** END  complete */
+
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            _setMinDelay(chainIds[i], minDelay);
+        }
+
+        (
+            address[] memory targets,
+            uint256[] memory values,
+            bytes[] memory calldatas,
+            uint256[] memory chainIds2
+        ) = _wrap(subCalls);
+        _serializeJson(targets, values, calldatas, chainIds2, description);
+    }
+}
diff --git a/test/scripts/ScriptHelpers.t.sol b/test/scripts/ScriptHelpers.t.sol
new file mode 100644
index 0000000..689e488
--- /dev/null
+++ b/test/scripts/ScriptHelpers.t.sol
@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.9;
+
+import { console } from "forge-std/console.sol";
+import { Vm } from "forge-std/Vm.sol";
+import { stdStorage, StdStorage, Test, stdError } from "forge-std/Test.sol";
+
+import { AngleGovernor } from "contracts/AngleGovernor.sol";
+import "../../scripts/Constants.s.sol";
+import "../../scripts/Utils.s.sol";
+
+//solhint-disable
+contract ScriptHelpers is Test, Utils {
+    using stdStorage for StdStorage;
+
+    uint256 constant valueEther = 1 ether;
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        // TODO remove when on chain tx are passed to connect chains
+        vm.selectFork(forkIdentifier[CHAIN_SOURCE]);
+        ProposalSender proposalSender = ProposalSender(
+            payable(_chainToContract(CHAIN_SOURCE, ContractType.ProposalSender))
+        );
+        uint256[] memory ALL_CHAINS = new uint256[](10);
+        ALL_CHAINS[0] = CHAIN_LINEA;
+        ALL_CHAINS[1] = CHAIN_POLYGON;
+        ALL_CHAINS[2] = CHAIN_ARBITRUM;
+        ALL_CHAINS[3] = CHAIN_AVALANCHE;
+        ALL_CHAINS[4] = CHAIN_OPTIMISM;
+        ALL_CHAINS[5] = CHAIN_GNOSIS;
+        ALL_CHAINS[6] = CHAIN_BNB;
+        ALL_CHAINS[7] = CHAIN_CELO;
+        ALL_CHAINS[8] = CHAIN_POLYGONZKEVM;
+        ALL_CHAINS[9] = CHAIN_BASE;
+
+        vm.startPrank(_chainToContract(CHAIN_SOURCE, ContractType.Governor));
+        for (uint256 i; i < ALL_CHAINS.length; i++) {
+            uint256 chainId = ALL_CHAINS[i];
+            proposalSender.setTrustedRemoteAddress(
+                getLZChainId(chainId),
+                abi.encodePacked(_chainToContract(chainId, ContractType.ProposalReceiver))
+            );
+        }
+        vm.stopPrank();
+    }
+
+    function _executeProposal() public returns (uint256[] memory) {
+        (
+            bytes[] memory calldatas,
+            string memory description,
+            address[] memory targets,
+            uint256[] memory values,
+            uint256[] memory chainIds
+        ) = _deserializeJson();
+
+        vm.selectFork(forkIdentifier[CHAIN_SOURCE]);
+        {
+            AngleGovernor governor = AngleGovernor(payable(_chainToContract(CHAIN_SOURCE, ContractType.Governor)));
+
+            {
+                hoax(whale);
+                uint256 proposalId = governor.propose(targets, values, calldatas, description);
+                vm.warp(block.timestamp + governor.votingDelay() + 1);
+                vm.roll(block.number + governor.$votingDelayBlocks() + 1);
+
+                hoax(whale);
+                governor.castVote(proposalId, 1);
+                vm.warp(block.timestamp + governor.votingPeriod() + 1);
+            }
+
+            vm.recordLogs();
+            hoax(whale);
+            governor.execute{ value: valueEther }(targets, values, calldatas, keccak256(bytes(description)));
+        }
+        Vm.Log[] memory entries = vm.getRecordedLogs();
+
+        for (uint256 chainCount; chainCount < chainIds.length; chainCount++) {
+            uint256 chainId = chainIds[chainCount];
+            TimelockControllerWithCounter timelock = TimelockControllerWithCounter(
+                payable(_chainToContract(chainId, ContractType.Timelock))
+            );
+
+            if (chainId == CHAIN_SOURCE) {
+                vm.warp(block.timestamp + timelock.getMinDelay() + 1);
+                _executeTimelock(chainId, timelock, targets[chainCount], calldatas[chainCount]);
+            } else {
+                {
+                    ProposalSender proposalSender = ProposalSender(
+                        payable(_chainToContract(CHAIN_SOURCE, ContractType.ProposalSender))
+                    );
+                    ProposalReceiver proposalReceiver = ProposalReceiver(
+                        payable(_chainToContract(chainId, ContractType.ProposalReceiver))
+                    );
+                    bytes memory payload;
+
+                    {
+                        for (uint256 i; i < entries.length; i++) {
+                            if (
+                                entries[i].topics[0] == keccak256("ExecuteRemoteProposal(uint16,bytes)") &&
+                                entries[i].topics[1] == bytes32(uint256(getLZChainId(chainId)))
+                            ) {
+                                payload = abi.decode(entries[i].data, (bytes));
+                                break;
+                            }
+                        }
+                    }
+
+                    vm.selectFork(forkIdentifier[chainId]);
+                    hoax(address(lzEndPoint(chainId)));
+                    proposalReceiver.lzReceive(
+                        getLZChainId(CHAIN_SOURCE),
+                        abi.encodePacked(proposalSender, proposalReceiver),
+                        0,
+                        payload
+                    );
+                }
+
+                vm.warp(block.timestamp + timelock.getMinDelay() + 1);
+                address[] memory chainTargets;
+                bytes[] memory chainCalldatas;
+                {
+                    console.logBytes(calldatas[chainCount]);
+                    (, bytes memory senderData, ) = abi.decode(
+                        // calldatas[chainCount],
+                        slice(calldatas[chainCount], 4, calldatas[chainCount].length - 4),
+                        (uint16, bytes, bytes)
+                    );
+                    console.logBytes(senderData);
+                    (chainTargets, , , chainCalldatas) = abi.decode(
+                        senderData,
+                        (address[], uint256[], string[], bytes[])
+                    );
+                }
+
+                for (uint256 i; i < chainTargets.length; i++) {
+                    _executeTimelock(chainId, timelock, chainTargets[i], chainCalldatas[i]);
+                }
+            }
+        }
+        return chainIds;
+    }
+
+    function _executeTimelock(
+        uint256 chainId,
+        TimelockControllerWithCounter timelock,
+        address target,
+        bytes memory rawData
+    ) public returns (uint256[] memory) {
+        // We only consider when transaction is sent to the chain timelock, as the other case shouldn't ask for another execute call
+        if (target == address(timelock)) {
+            vm.prank(_chainToContract(chainId, ContractType.GuardianMultisig));
+            if (TimelockControllerWithCounter.schedule.selector == bytes4(slice(rawData, 0, 4))) {
+                (address target, uint256 value, bytes memory data, bytes32 predecessor, bytes32 salt, ) = abi.decode(
+                    slice(rawData, 4, rawData.length - 4),
+                    (address, uint256, bytes, bytes32, bytes32, uint256)
+                );
+                timelock.execute(target, value, data, predecessor, salt);
+            } else {
+                (
+                    address[] memory tmpTargets,
+                    uint256[] memory tmpValues,
+                    bytes[] memory tmpCalldatas,
+                    bytes32 predecessor,
+                    bytes32 salt,
+
+                ) = abi.decode(
+                        slice(rawData, 4, rawData.length - 4),
+                        (address[], uint256[], bytes[], bytes32, bytes32, uint256)
+                    );
+                timelock.executeBatch(tmpTargets, tmpValues, tmpCalldatas, predecessor, salt);
+            }
+        }
+    }
+}
diff --git a/test/scripts/savings/SavingsSetRateTest.t.sol b/test/scripts/savings/SavingsSetRateTest.t.sol
new file mode 100644
index 0000000..d89d5c6
--- /dev/null
+++ b/test/scripts/savings/SavingsSetRateTest.t.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.19;
+
+import { stdJson } from "forge-std/StdJson.sol";
+import { console } from "forge-std/console.sol";
+import { ScriptHelpers } from "../ScriptHelpers.t.sol";
+import "../../../scripts/Constants.s.sol";
+import { TimelockControllerWithCounter } from "contracts/TimelockControllerWithCounter.sol";
+import { ProposalSender } from "contracts/ProposalSender.sol";
+
+contract SavingsSetRateTest is ScriptHelpers {
+    using stdJson for string;
+
+    uint256 constant newRate = fourPoint3Rate;
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function testScript() external {
+        uint256[] memory chainIds = _executeProposal();
+
+        // Now test that everything is as expected
+        for (uint256 i; i < chainIds.length; i++) {
+            uint256 chainId = chainIds[i];
+            ISavings stEUR = ISavings(payable(_chainToContract(chainId, ContractType.StEUR)));
+            vm.selectFork(forkIdentifier[chainId]);
+            uint256 rate = stEUR.rate();
+            assertEq(rate, newRate);
+        }
+    }
+}
diff --git a/test/scripts/timelock/SetMinDelayTimelockTest.t.sol b/test/scripts/timelock/SetMinDelayTimelockTest.t.sol
new file mode 100644
index 0000000..fa9913d
--- /dev/null
+++ b/test/scripts/timelock/SetMinDelayTimelockTest.t.sol
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.19;
+
+import { stdJson } from "forge-std/StdJson.sol";
+import { console } from "forge-std/console.sol";
+import { ScriptHelpers } from "../ScriptHelpers.t.sol";
+import "../../../scripts/Constants.s.sol";
+import { TimelockControllerWithCounter } from "contracts/TimelockControllerWithCounter.sol";
+import { ProposalSender } from "contracts/ProposalSender.sol";
+
+contract SetMinDelayTimelockTest is ScriptHelpers {
+    using stdJson for string;
+
+    uint256 constant newMinDelay = uint256(1 weeks);
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function testScript() external {
+        uint256[] memory chainIds = _executeProposal();
+
+        // Now test that everything is as expected
+        for (uint256 i; i < chainIds.length; i++) {
+            uint256 chainId = chainIds[i];
+            TimelockControllerWithCounter timelock = TimelockControllerWithCounter(
+                payable(_chainToContract(chainId, ContractType.Timelock))
+            );
+            vm.selectFork(forkIdentifier[chainId]);
+            uint256 minDelay = timelock.getMinDelay();
+            assertEq(minDelay, newMinDelay);
+        }
+    }
+}
diff --git a/test/unit/SimulationSetup.t.sol b/test/unit/SimulationSetup.t.sol
index 643a073..331c9ac 100644
--- a/test/unit/SimulationSetup.t.sol
+++ b/test/unit/SimulationSetup.t.sol
@@ -204,6 +204,7 @@ contract SimulationSetup is Test {
                                                         HELPERS                                                     
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
+    // TODO USE IT
     /// @notice Build the governor proposal based on all the transaction that need to be executed
     function wrap(
         SubCall[] memory prop
diff --git a/yarn.lock b/yarn.lock
index 8f90319..0b32c6a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,10 +2,10 @@
 # yarn lockfile v1
 
 
-"@angleprotocol/sdk@0.20.0":
-  version "0.20.0"
-  resolved "https://npm.pkg.github.com/download/@angleprotocol/sdk/0.20.0/5905906aef82e97cd217b3e63881323f9379b205#5905906aef82e97cd217b3e63881323f9379b205"
-  integrity sha512-IHGbHsywZn7W42d6pm/btj6a3ZeWyCxZd36Fubl+Fq9EMYqHjc+nfeclmMkHfMQJwihOpbMrCAohy8MfeL5usw==
+"@angleprotocol/sdk@^0.25.0":
+  version "0.25.0"
+  resolved "https://npm.pkg.github.com/download/@angleprotocol/sdk/0.25.0/5ae64a565f6bfc3459ce1442360539fc9438decc#5ae64a565f6bfc3459ce1442360539fc9438decc"
+  integrity sha512-AX3MAfmLOrPnP/rfhWF6djEWlcFOIL/mEEKIJY6h8kKUMJjVm2NQyGmrryJD0aCyi5/0MaB9dQNOAqj5yhkx+w==
   dependencies:
     "@apollo/client" "^3.7.17"
     "@typechain/ethers-v5" "^10.0.0"