diff --git a/.env.deployments.mainnet b/.env.deployments.mainnet
index 61ec7ea80..7108022b5 100644
--- a/.env.deployments.mainnet
+++ b/.env.deployments.mainnet
@@ -5,10 +5,10 @@ CONCERO_INFRA_PROXY_POLYGON=0x0AE1B2730066AD46481ab0a5fd2B5893f8aBa323
 CONCERO_INFRA_PROXY_AVALANCHE=0x0AE1B2730066AD46481ab0a5fd2B5893f8aBa323
 
 # INFRA PROXY ADMIN CONTRACT
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_BASE=0x3888A36fF10D894DA4000c94340C40761138C69F
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_AVALANCHE=0xF069f384a177083c4d62539e187860d2e163b0F4
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_POLYGON=0xF069f384a177083c4d62539e187860d2e163b0F4
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_ARBITRUM=0xF069f384a177083c4d62539e187860d2e163b0F4
+CONCERO_INFRA_PROXY_ADMIN_BASE=0x3888A36fF10D894DA4000c94340C40761138C69F
+CONCERO_INFRA_PROXY_ADMIN_AVALANCHE=0xF069f384a177083c4d62539e187860d2e163b0F4
+CONCERO_INFRA_PROXY_ADMIN_POLYGON=0xF069f384a177083c4d62539e187860d2e163b0F4
+CONCERO_INFRA_PROXY_ADMIN_ARBITRUM=0xF069f384a177083c4d62539e187860d2e163b0F4
 
 # BRIDGE CONTRACTS MAINNET
 CONCERO_BRIDGE_BASE=0x9c3Ab328f91A82a0a63896ebaC92364Ea527AaFf
@@ -34,9 +34,9 @@ CHILD_POOL_PROXY_POLYGON=0x164c20A4E11cBE0d8B5e23F5EE35675890BE280d
 CHILD_POOL_PROXY_AVALANCHE=0x164c20A4E11cBE0d8B5e23F5EE35675890BE280d
 
 # CHILD POOLS PROXY ADMIN CONTRACTS MAINNET
-CHILD_POOL_PROXY_ADMIN_CONTRACT_ARBITRUM=0x3888A36fF10D894DA4000c94340C40761138C69F
-CHILD_POOL_PROXY_ADMIN_CONTRACT_AVALANCHE=0x3888A36fF10D894DA4000c94340C40761138C69F
-CHILD_POOL_PROXY_ADMIN_CONTRACT_POLYGON=0x3888A36fF10D894DA4000c94340C40761138C69F
+CHILD_POOL_PROXY_ADMIN_ARBITRUM=0x3888A36fF10D894DA4000c94340C40761138C69F
+CHILD_POOL_PROXY_ADMIN_AVALANCHE=0x3888A36fF10D894DA4000c94340C40761138C69F
+CHILD_POOL_PROXY_ADMIN_POLYGON=0x3888A36fF10D894DA4000c94340C40761138C69F
 
 ### CHILD POOLS IMPLEMENTATIONS MAINNET ###
 CHILD_POOL_ARBITRUM=0x33a3d7150D13798B1f4163F62bC5070336fDda0B
@@ -47,7 +47,7 @@ CHILD_POOL_AVALANCHE=0xBE7b5f0F11E297F9b0a2a7400ca597e1c627639f
 PARENT_POOL_PROXY_BASE=0x0AE1B2730066AD46481ab0a5fd2B5893f8aBa323
 
 ### PARENT POOL PROXY ADMIN CONTRACTS ###
-PARENT_POOL_PROXY_ADMIN_CONTRACT_BASE=0xF069f384a177083c4d62539e187860d2e163b0F4
+PARENT_POOL_PROXY_ADMIN_BASE=0xF069f384a177083c4d62539e187860d2e163b0F4
 
 ### PARENT POOL IMPLEMENTATION PRODUCTION CONTRACTS ADDRESSES ###
 PARENT_POOL_BASE=0x8eBC9C9BDB0b5Cd22838f15Fbd18862dB1d7f8d4
diff --git a/.env.deployments.testnet b/.env.deployments.testnet
index f623ca79f..9df83c8a4 100644
--- a/.env.deployments.testnet
+++ b/.env.deployments.testnet
@@ -1,30 +1,30 @@
 ### INFRA PROXY CONTRACTS ADDRESSES ###
 ## todo: when this infra proxy env var is not set, deploy script throws error:
 ## todo: Error: Missing required environment variable CONCERO_INFRA_PROXY_FUJI
+CONCERO_INFRA_PROXY_BASE_SEPOLIA=0xb7A02DFB077B0c909A5D7aCcEdd716f4c36DEF41
 CONCERO_INFRA_PROXY_FUJI=0x0Db7753a6ad115B129202ce499e23578b2991Eb0
-CONCERO_INFRA_PROXY_BASE_SEPOLIA=0xAb1495878a1BBcd23ec69A2ECA16A0357334447d
 CONCERO_INFRA_PROXY_ARBITRUM_SEPOLIA=0x4dfD6f3ffB7f6426793D55dEAb3783375206aaEd
 
 ### INFRA PROXY ADMIN CONTRACTS ###
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_BASE_SEPOLIA=0xdAf5AECA9Fb62CcaAe98B5b0e8F3030047868e9B
-CONCERO_INFRA_PROXY_ADMIN_CONTRACT_ARBITRUM_SEPOLIA=0x4a63B67d5bd94e3CfA8fEa1498085b9684b084ec
+CONCERO_INFRA_PROXY_ADMIN_BASE_SEPOLIA=0x7cB2398963f8969ABB7FB7544b4FD97530B062b9
+CONCERO_INFRA_PROXY_ADMIN_ARBITRUM_SEPOLIA=0x4a63B67d5bd94e3CfA8fEa1498085b9684b084ec
 
 ### BRIDGE CONTRACTS ADDRESSES ###
 CONCERO_BRIDGE_SEPOLIA=""
 CONCERO_BRIDGE_FUJI=""
 CONCERO_BRIDGE_ARBITRUM_SEPOLIA=0x1464A54b9DF0a92877c087644941C11b598e9921
-CONCERO_BRIDGE_BASE_SEPOLIA=0x81B0CbF3131aEA76788660d0f94a515e0fa96C87
+CONCERO_BRIDGE_BASE_SEPOLIA=0x00E6DB575cE7379F0ab09E952565a5607685620a
 CONCERO_BRIDGE_OPTIMISM_SEPOLIA=0x1CACCEe6bBB49A1391471192f6e013079191C367
 CONCERO_BRIDGE_POLYGON_AMOY=0xC432d1c19F80E04f0D9A8BA19E890A77D34131C8
 
 ### PARENT POOL PROXY CONTRACTS ADDRESSES ###
-PARENT_POOL_PROXY_BASE_SEPOLIA=0xC80ff076966e86B62C5c9134FbC3D1439C09f6B6
+PARENT_POOL_PROXY_BASE_SEPOLIA=0x6dCC61b865aA11FA502AeAdABb5269f6a8fB7d61
 
 ### PARENT POOL PROXY ADMIN CONTRACTS ###
-PARENT_POOL_PROXY_ADMIN_CONTRACT_BASE_SEPOLIA=0x4FEb1b24b55564F7aB0C0b336b64CE4906354a39
+PARENT_POOL_PROXY_ADMIN_BASE_SEPOLIA=0xED71d1FDC6857D313Fe3705adB4133fDf2fdFE8f
 
 ### PARENT POOL CONTRACTS ADDRESSES ###
-PARENT_POOL_BASE_SEPOLIA=0x769Ef1290414eAD0096118f26CdF135375A80eec
+PARENT_POOL_BASE_SEPOLIA=""
 
 ### AUTOMATIONS CONTRACTS ADDRESSES ###
 CONCERO_AUTOMATION_BASE_SEPOLIA=0xF78297412C4b74aC451b16Fe1e6F0FfDc9F5D9C1
@@ -37,9 +37,9 @@ CHILD_POOL_PROXY_ARBITRUM_SEPOLIA=0x1bb4233765838Ee69076845D10fa231c8cd500a3
 CHILD_POOL_PROXY_FUJI=0xED007301D6AfacD5FA30Fb2fD4B45951A064f798
 
 ### CHILD POOL PROXY ADMIN CONTRACTS ###
-CHILD_POOL_PROXY_ADMIN_CONTRACT_ARBITRUM_SEPOLIA=0xED007301D6AfacD5FA30Fb2fD4B45951A064f798
-CHILD_POOL_PROXY_ADMIN_CONTRACT_FUJI=0xab2C8D956308AB91EBfe6034abdCd8c3bf650298
-CHILD_POOL_PROXY_ADMIN_CONTRACT_BASE_SEPOLIA=""
+CHILD_POOL_PROXY_ADMIN_ARBITRUM_SEPOLIA=0xED007301D6AfacD5FA30Fb2fD4B45951A064f798
+CHILD_POOL_PROXY_ADMIN_FUJI=0xab2C8D956308AB91EBfe6034abdCd8c3bf650298
+CHILD_POOL_PROXY_ADMIN_BASE_SEPOLIA=""
 
 ### CHILD POOL IMPLEMENTATIONS ###
 CHILD_POOL_BASE_SEPOLIA=""
@@ -51,13 +51,13 @@ CHILD_POOL_SEPOLIA=""
 CHILD_POOL_POLYGON_AMOY=""
 
 # DEX SWAP
-CONCERO_DEX_SWAP_BASE_SEPOLIA=0x08b726F8A669D6e1c4CD1c87De5e83c197Bffd29
+CONCERO_DEX_SWAP_BASE_SEPOLIA=0xE07297F9B8dfC4C3c2E7ad174B2596356f9Bc1FE
 CONCERO_DEX_SWAP_OPTIMISM_SEPOLIA=0xD4437bE364F065Fba62E08899aD3219cbE3fAa4A
 CONCERO_DEX_SWAP_ARBITRUM_SEPOLIA=0x48887B04abF5fe71Ae444739B5E6C93C9B9CfDCc
 CONCERO_DEX_SWAP_POLYGON_AMOY=0x4713f263E826c700aA2B4df6760973dBCfFF0cce
 
 # ORCHESTRATOR
-CONCERO_ORCHESTRATOR_BASE_SEPOLIA=0x1A0BC347Aea62f95650637EB1F83d12a9FB573b6
+CONCERO_ORCHESTRATOR_BASE_SEPOLIA=0x4c5a71adddeFA0551ff2C6DE7363AFfc918ff32d
 CONCERO_ORCHESTRATOR_OPTIMISM_SEPOLIA=0x2B22a64f932739a2CB392dd38A9B2f087072b0D1
 CONCERO_ORCHESTRATOR_ARBITRUM_SEPOLIA=0xb8a36C25bCCe9beF4632ff97581427D40255327B
 CONCERO_ORCHESTRATOR_POLYGON_AMOY=0x8Bd9245B23780047ae5B0F8aCF31F217Aa207CBB
@@ -66,3 +66,4 @@ CONCERO_ORCHESTRATOR_POLYGON_AMOY=0x8Bd9245B23780047ae5B0F8aCF31F217Aa207CBB
 CONCERO_PAUSE_BASE_SEPOLIA=0x45c1C5fDe180a7a23B6D4ae03Ee015102436Ce37
 CONCERO_PAUSE_ARBITRUM_SEPOLIA=0x6c7B572ae10f7d5c79128e68Ce1A43A16311dE3f
 CONCERO_PAUSE_FUJI=0x0Db7753a6ad115B129202ce499e23578b2991Eb0
+
diff --git a/packages/hardhat/constants/deploymentVariables.ts b/packages/hardhat/constants/deploymentVariables.ts
index 47a9c3e0e..c79d83eaf 100644
--- a/packages/hardhat/constants/deploymentVariables.ts
+++ b/packages/hardhat/constants/deploymentVariables.ts
@@ -12,23 +12,25 @@ export const poolMessengers: string[] = [
   getEnvVar("POOL_MESSENGER_0_ADDRESS"),
 ];
 // The address is the same on 4 chains: ARB,POL,BASE,AVAX. Can be deployed to others later using Lifi's Create3 Factory.
-export const initialProxyImplementationAddress = getEnvVar("CONCERO_PAUSE_ARBITRUM");
 
 export const viemReceiptConfig: WaitForTransactionReceiptParameters = {
   timeout: 0,
   confirmations: 2,
 };
 
-export type DeploymentPrefixes = {
-  infraProxy: string;
+export type ProxyType = "infraProxy" | "parentPoolProxy" | "childPoolProxy";
+
+type ProxyDeploymentPrefixes = {
+  [key in ProxyType]: string;
+};
+
+export type DeploymentPrefixes = ProxyDeploymentPrefixes & {
   infraProxyAdmin: string;
   bridge: string;
   dexSwap: string;
   orchestrator: string;
-  parentPoolProxy: string;
   parentPoolProxyAdmin: string;
   parentPool: string;
-  childPoolProxy: string;
   childPoolProxyAdmin: string;
   childPool: string;
   automation: string;
diff --git a/packages/hardhat/contracts/ConceroChildPool.sol b/packages/hardhat/contracts/ConceroChildPool.sol
index 56434ba25..c3706e3c9 100644
--- a/packages/hardhat/contracts/ConceroChildPool.sol
+++ b/packages/hardhat/contracts/ConceroChildPool.sol
@@ -372,6 +372,7 @@ contract ConceroChildPool is CCIPReceiver, ChildPoolStorage {
      * @dev This function will sent the address of the user as data. This address will be used to update the mapping on ParentPool.
      * @dev when processing withdrawals, the _chainSelector will always be the index 0 of s_poolChainSelectors
      */
+    //todo: rename _lpAddress
     function _ccipSend(
         uint64 _chainSelector,
         address _lpAddress,
diff --git a/packages/hardhat/contracts/ConceroParentPool.sol b/packages/hardhat/contracts/ConceroParentPool.sol
index 583cc8c8f..875619ca0 100644
--- a/packages/hardhat/contracts/ConceroParentPool.sol
+++ b/packages/hardhat/contracts/ConceroParentPool.sol
@@ -905,6 +905,7 @@ contract ConceroParentPool is
         } else if (requestType == RequestType.performUpkeep_requestLiquidityTransfer) {
             _handleAutomationCLFFulfill(requestId, response);
         }
+        //todo: in case of set/remove pools we're deleting a requestId that we haven't stored
         delete s_clfRequestTypes[requestId];
     }
 
diff --git a/packages/hardhat/deploy/00_InfraProxy.ts b/packages/hardhat/deploy/00_InfraProxy.ts
deleted file mode 100644
index 0a4793257..000000000
--- a/packages/hardhat/deploy/00_InfraProxy.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// import { DeployFunction, Deployment } from "hardhat-deploy/types";
-// import { HardhatRuntimeEnvironment } from "hardhat/types";
-// import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
-// import updateEnvVariable from "../utils/updateEnvVariable";
-// import log from "../utils/log";
-// import { getClients } from "../tasks/utils/getViemClients";
-// import { initialProxyImplementationAddress } from "../constants/deploymentVariables";
-//
-// REPLACED BY 11_TransparentProxy.ts
-// const deployConceroProxy: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-//   const { deployer, proxyDeployer } = await hre.getNamedAccounts();
-//   const { deploy } = hre.deployments;
-//   const { name, live } = hre.network;
-//
-//   const { url: dcUrl, viemChain: dcViemChain, name: dcName } = CNetworks[name];
-//   const { publicClient } = getClients(dcViemChain, dcUrl);
-//   // const gasPrice = await publicClient.getGasPrice();
-//
-//   console.log("Deploying InfraProxy...");
-//   const conceroProxyDeployment = (await deploy("InfraProxy", {
-//     from: proxyDeployer,
-//     args: [initialProxyImplementationAddress, proxyDeployer, "0x"],
-//     log: true,
-//     autoMine: true,
-//     // gasPrice: gasPrice.toString(),
-//     // gasLimit: "1000000",
-//   })) as Deployment;
-//
-//    if (live) {
-//     log(`InfraProxy deployed to ${name} to: ${conceroProxyDeployment.address}`, "deployInfraProxy");
-//     updateEnvVariable(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`, conceroProxyDeployment.address, "../../../.env.deployments");
-//   }
-// };
-//
-// export default deployConceroProxy;
-// deployConceroProxy.tags = ["InfraProxy"];
diff --git a/packages/hardhat/deploy/01_ConceroFakePool.ts b/packages/hardhat/deploy/01_ConceroFakePool.ts
index 7e818f346..5b99edf31 100644
--- a/packages/hardhat/deploy/01_ConceroFakePool.ts
+++ b/packages/hardhat/deploy/01_ConceroFakePool.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains from "../constants/CNetworks";
 import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
@@ -11,41 +11,39 @@ interface ConstructorArgs {
   ccipRouter?: string;
 }
 
-const deployConceroPool: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-) {
-  const { deployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
-  const networkType = CNetworks[name].type;
-
-  const { linkToken, ccipRouter } = chains[name];
-
-  const defaultArgs = {
-    linkToken: linkToken,
-    ccipRouter: ccipRouter,
-    conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
+const deployConceroPool: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { deployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
+    const networkType = CNetworks[name].type;
+
+    const { linkToken, ccipRouter } = chains[name];
+
+    const defaultArgs = {
+      linkToken: linkToken,
+      ccipRouter: ccipRouter,
+      conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
+    };
+
+    // Merge defaultArgs with constructorArgs
+    const args = { ...defaultArgs, ...constructorArgs };
+
+    console.log("Deploying ConceroPool...");
+    // const deployConceroPool = (await deploy("ConceroPool", {
+    const deployConceroPool = (await deploy("FakePool", {
+      from: deployer,
+      // args: [args.linkToken, args.ccipRouter, args.conceroProxyAddress],
+      args: [args.ccipRouter, args.conceroProxyAddress],
+      log: true,
+      autoMine: true,
+    })) as Deployment;
+
+    if (live) {
+      log(`ConceroPool deployed to ${name} to: ${deployConceroPool.address}`, "deployConceroPool");
+      updateEnvVariable(`CONCEROPOOL_${networkEnvKeys[name]}`, deployConceroPool.address, `deployments.${networkType}`);
+    }
   };
 
-  // Merge defaultArgs with constructorArgs
-  const args = { ...defaultArgs, ...constructorArgs };
-
-  console.log("Deploying ConceroPool...");
-  // const deployConceroPool = (await deploy("ConceroPool", {
-  const deployConceroPool = (await deploy("FakePool", {
-    from: deployer,
-    // args: [args.linkToken, args.ccipRouter, args.conceroProxyAddress],
-    args: [args.ccipRouter, args.conceroProxyAddress],
-    log: true,
-    autoMine: true,
-  })) as Deployment;
-
-  if (live) {
-    log(`ConceroPool deployed to ${name} to: ${deployConceroPool.address}`, "deployConceroPool");
-    updateEnvVariable(`CONCEROPOOL_${networkEnvKeys[name]}`, deployConceroPool.address, `deployments.${networkType}`);
-  }
-};
-
 export default deployConceroPool;
 deployConceroPool.tags = ["ConceroPool"];
diff --git a/packages/hardhat/deploy/01_ParentPoolProxy.ts b/packages/hardhat/deploy/01_ParentPoolProxy.ts
deleted file mode 100644
index 8af689312..000000000
--- a/packages/hardhat/deploy/01_ParentPoolProxy.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-// import { DeployFunction, Deployment } from "hardhat-deploy/types";
-// import { HardhatRuntimeEnvironment } from "hardhat/types";
-// import { networkEnvKeys } from "../constants/CNetworks";
-// import updateEnvVariable from "../utils/updateEnvVariable";
-// import log from "../utils/log";
-// import { getEnvVar } from "../utils/getEnvVar";
-// // import { initialProxyImplementationAddress } from "../constants/deploymentVariables";
-//
-// REPLACED BY 11_TransparentProxy.ts
-// const deployParentProxy: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-//   const { deployer, proxyDeployer } = await hre.getNamedAccounts();
-//
-//   const { deploy } = hre.deployments;
-//   const { name, live } = hre.network;
-//
-//   const implementationAddress = getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`);
-//
-//   console.log("Deploying ParentProxy...");
-//   const deployParentProxy = (await deploy("ParentPoolProxy", {
-//     from: proxyDeployer,
-//     args: [implementationAddress, proxyDeployer, "0x"],
-//     log: true,
-//     autoMine: true,
-//     gasLimit: 2_000_000,
-//   })) as Deployment;
-//
-//    if (live) {
-//     log(`ParentProxy deployed to ${name} to: ${deployParentProxy.address}`, "deployParentProxy");
-//     updateEnvVariable(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`, deployParentProxy.address, "../../../.env.deployments");
-//   }
-// };
-//
-// export default deployParentProxy;
-// deployParentProxy.tags = ["ParentProxy"];
diff --git a/packages/hardhat/deploy/02_ChildPoolProxy.ts b/packages/hardhat/deploy/02_ChildPoolProxy.ts
deleted file mode 100644
index 18826119d..000000000
--- a/packages/hardhat/deploy/02_ChildPoolProxy.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-// import { DeployFunction, Deployment } from "hardhat-deploy/types";
-// import { HardhatRuntimeEnvironment } from "hardhat/types";
-// import { networkEnvKeys } from "../constants/CNetworks";
-// import updateEnvVariable from "../utils/updateEnvVariable";
-// import log from "../utils/log";
-// // import { initialProxyImplementationAddress } from "../constants/deploymentVariables";
-// import { getEnvVar } from "../utils/getEnvVar";
-//
-// REPLACED BY 11_TransparentProxy.ts
-// const deployChildProxy: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-//   const { deployer, proxyDeployer } = await hre.getNamedAccounts();
-//   const { deploy } = hre.deployments;
-//   const { name, live } = hre.network;
-//
-//   const implementationAddress = getEnvVar(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`);
-//
-//   console.log("Deploying ChildProxy...");
-//   const deployChildProxy = (await deploy("ChildPoolProxy", {
-//     from: proxyDeployer,
-//     args: [implementationAddress, proxyDeployer, "0x"],
-//     log: true,
-//     autoMine: true,
-//   })) as Deployment;
-//
-//    if (live) {
-//     log(`ChildPoolProxy deployed to ${name} to: ${deployChildProxy.address}`, "deployChildPoolProxy");
-//     updateEnvVariable(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`, deployChildProxy.address, "../../../.env.deployments");
-//   }
-// };
-//
-// export default deployChildProxy;
-// deployChildProxy.tags = ["ChildPoolProxy"];
diff --git a/packages/hardhat/deploy/03_ConceroDexSwap.ts b/packages/hardhat/deploy/03_ConceroDexSwap.ts
index d98a9a310..75310c6a1 100644
--- a/packages/hardhat/deploy/03_ConceroDexSwap.ts
+++ b/packages/hardhat/deploy/03_ConceroDexSwap.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -6,7 +6,9 @@ import log from "../utils/log";
 import { getEnvVar } from "../utils/getEnvVar";
 import { messengers } from "../constants/deploymentVariables";
 
-const deployConceroDexSwap: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+const deployConceroDexSwap: (hre: HardhatRuntimeEnvironment) => Promise<void> = async function (
+  hre: HardhatRuntimeEnvironment,
+) {
   const { deployer } = await hre.getNamedAccounts();
   const { deploy } = hre.deployments;
   const { name, live } = hre.network;
@@ -14,7 +16,8 @@ const deployConceroDexSwap: DeployFunction = async function (hre: HardhatRuntime
 
   const conceroProxyAddress = getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`);
 
-  console.log("Deploying ConceroDexSwap...");
+  log("Deploying...", "DexSwap", name);
+
   const deployResult = (await deploy("DexSwap", {
     from: deployer,
     args: [conceroProxyAddress, messengers],
diff --git a/packages/hardhat/deploy/04_ConceroBridge.ts b/packages/hardhat/deploy/04_ConceroBridge.ts
index e0a38d76e..08e5e78f4 100644
--- a/packages/hardhat/deploy/04_ConceroBridge.ts
+++ b/packages/hardhat/deploy/04_ConceroBridge.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -23,89 +23,86 @@ interface ConstructorArgs {
 }
 
 /* run with: yarn deploy --network avalancheFuji --tags Concero */
-const deployConceroBridge: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-) {
-  const { deployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
-  const networkType = chains[name].type;
+const deployConceroBridge: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { deployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
+    const networkType = chains[name].type;
 
-  if (!chains[name]) throw new Error(`Chain ${name} not supported`);
+    if (!chains[name]) throw new Error(`Chain ${name} not supported`);
 
-  const {
-    functionsRouter,
-    donHostedSecretsVersion,
-    functionsDonId,
-    functionsSubIds,
-    chainSelector,
-    conceroChainIndex,
-    linkToken,
-    ccipRouter,
-    priceFeed,
-  } = chains[name];
+    const {
+      functionsRouter,
+      donHostedSecretsVersion,
+      functionsDonId,
+      functionsSubIds,
+      chainSelector,
+      conceroChainIndex,
+      linkToken,
+      ccipRouter,
+    } = chains[name];
 
-  const jsPath = "./tasks/CLFScripts";
+    const jsPath = "./tasks/CLFScripts";
 
-  function getJS(jsPath: string, type: string): string {
-    // const source = path.join(jsPath, "src", `${type}.js`);
-    const dist = path.join(jsPath, "dist", `${type}.min.js`);
-    //
-    // if (!fs.existsSync(dist)) {
-    //   log(`File not found: ${dist}, building...`, "getJS");
-    //   buildScript(source);
-    // }
+    function getJS(jsPath: string, type: string): string {
+      // const source = path.join(jsPath, "src", `${type}.js`);
+      const dist = path.join(jsPath, "dist", `${type}.min.js`);
+      //
+      // if (!fs.existsSync(dist)) {
+      //   log(`File not found: ${dist}, building...`, "getJS");
+      //   buildScript(source);
+      // }
 
-    return fs.readFileSync(dist, "utf8");
-  }
+      return fs.readFileSync(dist, "utf8");
+    }
 
-  const defaultArgs = {
-    chainSelector: chainSelector,
-    conceroChainIndex: conceroChainIndex,
-    linkToken: linkToken,
-    ccipRouter: ccipRouter,
-    dexSwapModule: getEnvVar(`CONCERO_DEX_SWAP_${networkEnvKeys[name]}`),
-    functionsVars: {
-      donHostedSecretsSlotId: constructorArgs.slotId || 0,
-      donHostedSecretsVersion: donHostedSecretsVersion,
-      subscriptionId: functionsSubIds[0],
-      donId: functionsDonId,
-      functionsRouter: functionsRouter,
-    },
-    conceroPoolAddress:
-      name === "base" || name === "baseSepolia"
-        ? getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`)
-        : getEnvVar(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`),
-    conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
-    messengers,
-  };
+    const defaultArgs = {
+      chainSelector: chainSelector,
+      conceroChainIndex: conceroChainIndex,
+      linkToken: linkToken,
+      ccipRouter: ccipRouter,
+      dexSwapModule: getEnvVar(`CONCERO_DEX_SWAP_${networkEnvKeys[name]}`),
+      functionsVars: {
+        donHostedSecretsSlotId: constructorArgs.slotId || 0,
+        donHostedSecretsVersion: donHostedSecretsVersion,
+        subscriptionId: functionsSubIds[0],
+        donId: functionsDonId,
+        functionsRouter: functionsRouter,
+      },
+      conceroPoolAddress:
+        name === "base" || name === "baseSepolia"
+          ? getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`)
+          : getEnvVar(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`),
+      conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
+      messengers,
+    };
 
-  // Merge defaultArgs with constructorArgs
-  const args = { ...defaultArgs, ...constructorArgs };
+    // Merge defaultArgs with constructorArgs
+    const args = { ...defaultArgs, ...constructorArgs };
 
-  const deployment = (await deploy("ConceroBridge", {
-    from: deployer,
-    log: true,
-    args: [
-      args.functionsVars,
-      args.chainSelector,
-      args.conceroChainIndex,
-      args.linkToken,
-      args.ccipRouter,
-      args.dexSwapModule,
-      args.conceroPoolAddress,
-      args.conceroProxyAddress,
-      args.messengers,
-    ],
-    autoMine: true,
-  })) as Deployment;
+    const deployment = (await deploy("ConceroBridge", {
+      from: deployer,
+      log: true,
+      args: [
+        args.functionsVars,
+        args.chainSelector,
+        args.conceroChainIndex,
+        args.linkToken,
+        args.ccipRouter,
+        args.dexSwapModule,
+        args.conceroPoolAddress,
+        args.conceroProxyAddress,
+        args.messengers,
+      ],
+      autoMine: true,
+    })) as Deployment;
 
-  if (live) {
-    log(`Deployed at: ${deployment.address}`, "conceroBridge", name);
-    updateEnvVariable(`CONCERO_BRIDGE_${networkEnvKeys[name]}`, deployment.address, `deployments.${networkType}`);
-  }
-};
+    if (live) {
+      log(`Deployed at: ${deployment.address}`, "conceroBridge", name);
+      updateEnvVariable(`CONCERO_BRIDGE_${networkEnvKeys[name]}`, deployment.address, `deployments.${networkType}`);
+    }
+  };
 
 export default deployConceroBridge;
 deployConceroBridge.tags = ["ConceroBridge"];
diff --git a/packages/hardhat/deploy/05_ConceroOrchestrator.ts b/packages/hardhat/deploy/05_ConceroOrchestrator.ts
index bcf4fe402..fc830fa73 100644
--- a/packages/hardhat/deploy/05_ConceroOrchestrator.ts
+++ b/packages/hardhat/deploy/05_ConceroOrchestrator.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -6,7 +6,9 @@ import log from "../utils/log";
 import { getEnvVar } from "../utils/getEnvVar";
 import { messengers } from "../constants/deploymentVariables";
 
-const deployConceroOrchestrator: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+const deployConceroOrchestrator: (hre: HardhatRuntimeEnvironment) => Promise<void> = async function (
+  hre: HardhatRuntimeEnvironment,
+) {
   const { deployer } = await hre.getNamedAccounts();
   const { deploy } = hre.deployments;
   const { name, live } = hre.network;
@@ -23,7 +25,7 @@ const deployConceroOrchestrator: DeployFunction = async function (hre: HardhatRu
 
   const conceroProxyAddress = getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`);
 
-  console.log("Deploying ConceroOrchestrator...");
+  log("Deploying...", "ConceroOrchestrator", name);
 
   const conceroProxyDeployment = (await deploy("Orchestrator", {
     from: deployer,
diff --git a/packages/hardhat/deploy/06_ConceroAutomation.ts b/packages/hardhat/deploy/06_ConceroAutomation.ts
index 2a773a1e5..eb5df3dbc 100644
--- a/packages/hardhat/deploy/06_ConceroAutomation.ts
+++ b/packages/hardhat/deploy/06_ConceroAutomation.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -21,61 +21,59 @@ interface ConstructorArgs {
   owner?: string;
 }
 
-const deployConceroAutomation: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-) {
-  const { deployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
+const deployConceroAutomation: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { deployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
 
-  const { functionsRouter, functionsDonId, functionsSubIds, donHostedSecretsVersion, type } = chains[name];
+    const { functionsRouter, functionsDonId, functionsSubIds, donHostedSecretsVersion, type } = chains[name];
 
-  const jsPath = "./tasks/CLFScripts";
+    const jsPath = "./tasks/CLFScripts";
 
-  function getJS(jsPath: string, type: string): string {
-    const dist = path.join(jsPath, "dist", `${type}.min.js`);
-    return fs.readFileSync(dist, "utf8");
-  }
+    function getJS(jsPath: string, type: string): string {
+      const dist = path.join(jsPath, "dist", `${type}.min.js`);
+      return fs.readFileSync(dist, "utf8");
+    }
 
-  const defaultArgs = {
-    functionsDonId: functionsDonId,
-    functionsSubIds: functionsSubIds,
-    functionsSlotId: constructorArgs.slotId || 0,
-    donHostedSecretsVersion: donHostedSecretsVersion,
-    hashSum: getHashSum(getJS(jsPath, "pool/getTotalBalance")),
-    etherHashSum: getHashSum(await (await fetch(ethersV6CodeUrl)).text()),
-    functionsRouter: functionsRouter,
-    parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
-    owner: deployer,
-  };
+    const defaultArgs = {
+      functionsDonId: functionsDonId,
+      functionsSubIds: functionsSubIds,
+      functionsSlotId: constructorArgs.slotId || 0,
+      donHostedSecretsVersion: donHostedSecretsVersion,
+      hashSum: getHashSum(getJS(jsPath, "pool/getTotalBalance")),
+      etherHashSum: getHashSum(await (await fetch(ethersV6CodeUrl)).text()),
+      functionsRouter: functionsRouter,
+      parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
+      owner: deployer,
+    };
 
-  const args = { ...defaultArgs, ...constructorArgs };
+    const args = { ...defaultArgs, ...constructorArgs };
 
-  console.log("Deploying ConceroAutomation...");
-  const deployConceroAutomation = (await deploy("ConceroAutomation", {
-    from: deployer,
-    args: [
-      args.functionsDonId,
-      args.functionsSubIds[0],
-      args.functionsSlotId,
-      args.functionsRouter,
-      args.parentProxyAddress,
-      args.owner,
-    ],
-    log: true,
-    autoMine: true,
-  })) as Deployment;
+    console.log("Deploying ConceroAutomation...");
+    const deployConceroAutomation = (await deploy("ConceroAutomation", {
+      from: deployer,
+      args: [
+        args.functionsDonId,
+        args.functionsSubIds[0],
+        args.functionsSlotId,
+        args.functionsRouter,
+        args.parentProxyAddress,
+        args.owner,
+      ],
+      log: true,
+      autoMine: true,
+    })) as Deployment;
 
-  if (live) {
-    log(`ConceroAutomation deployed to ${name} to: ${deployConceroAutomation.address}`, "deployConceroAutomation");
-    updateEnvVariable(
-      `CONCERO_AUTOMATION_${networkEnvKeys[name]}`,
-      deployConceroAutomation.address,
-      `deployments.${type}`,
-    );
-  }
-};
+    if (live) {
+      log(`ConceroAutomation deployed to ${name} to: ${deployConceroAutomation.address}`, "deployConceroAutomation");
+      updateEnvVariable(
+        `CONCERO_AUTOMATION_${networkEnvKeys[name]}`,
+        deployConceroAutomation.address,
+        `deployments.${type}`,
+      );
+    }
+  };
 
 export default deployConceroAutomation;
 deployConceroAutomation.tags = ["ConceroAutomation"];
diff --git a/packages/hardhat/deploy/07_LPToken.ts b/packages/hardhat/deploy/07_LPToken.ts
index b029611c1..fb562a8b1 100644
--- a/packages/hardhat/deploy/07_LPToken.ts
+++ b/packages/hardhat/deploy/07_LPToken.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -10,35 +10,33 @@ interface ConstructorArgs {
   owner?: string;
 }
 
-const deployLPToken: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-) {
-  const { proxyDeployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
-  const networkType = CNetworks[name].type;
+const deployLPToken: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { proxyDeployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
+    const networkType = CNetworks[name].type;
 
-  const defaultArgs = {
-    parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
-    owner: proxyDeployer,
-  };
+    const defaultArgs = {
+      parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
+      owner: proxyDeployer,
+    };
 
-  const args = { ...defaultArgs, ...constructorArgs };
+    const args = { ...defaultArgs, ...constructorArgs };
 
-  console.log("Deploying LpToken...");
-  const deployLPToken = (await deploy("LPToken", {
-    from: proxyDeployer,
-    args: [args.owner, args.parentProxyAddress],
-    log: true,
-    autoMine: true,
-  })) as Deployment;
+    console.log("Deploying LpToken...");
+    const deployLPToken = (await deploy("LPToken", {
+      from: proxyDeployer,
+      args: [args.owner, args.parentProxyAddress],
+      log: true,
+      autoMine: true,
+    })) as Deployment;
 
-  if (live) {
-    log(`LpToken deployed to ${name} to: ${deployLPToken.address}`, "deployLPToken");
-    updateEnvVariable(`LPTOKEN_${networkEnvKeys[name]}`, deployLPToken.address, `deployments.${networkType}`);
-  }
-};
+    if (live) {
+      log(`LpToken deployed to ${name} to: ${deployLPToken.address}`, "deployLPToken");
+      updateEnvVariable(`LPTOKEN_${networkEnvKeys[name]}`, deployLPToken.address, `deployments.${networkType}`);
+    }
+  };
 
 export default deployLPToken;
 deployLPToken.tags = ["LpToken"];
diff --git a/packages/hardhat/deploy/08_ChildPool.ts b/packages/hardhat/deploy/08_ChildPool.ts
index d84ade0b5..2474fee8a 100644
--- a/packages/hardhat/deploy/08_ChildPool.ts
+++ b/packages/hardhat/deploy/08_ChildPool.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -18,51 +18,49 @@ interface ConstructorArgs {
   messengers?: string[];
 }
 
-const deployChildPool: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-  isMainnet = false,
-) {
-  const { deployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
+const deployChildPool: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { deployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
 
-  const { linkToken, ccipRouter, type } = chains[name];
+    const { linkToken, ccipRouter, type } = chains[name];
 
-  const defaultArgs = {
-    conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
-    childProxyAddress: getEnvVar(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`),
-    linkToken: linkToken,
-    ccipRouter: ccipRouter,
-    usdc: getEnvVar(`USDC_${networkEnvKeys[name]}`),
-    owner: deployer,
-    poolMessengers,
-  };
+    const defaultArgs = {
+      conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
+      childProxyAddress: getEnvVar(`CHILD_POOL_PROXY_${networkEnvKeys[name]}`),
+      linkToken: linkToken,
+      ccipRouter: ccipRouter,
+      usdc: getEnvVar(`USDC_${networkEnvKeys[name]}`),
+      owner: deployer,
+      poolMessengers,
+    };
+
+    // Merge defaultArgs with constructorArgs
+    const args = { ...defaultArgs, ...constructorArgs };
 
-  // Merge defaultArgs with constructorArgs
-  const args = { ...defaultArgs, ...constructorArgs };
+    log("Deploying...", "deployChildPool", name);
 
-  console.log("Deploying ChildPool...");
-  const deployChildPool = (await deploy("ConceroChildPool", {
-    from: deployer,
-    args: [
-      args.conceroProxyAddress,
-      args.childProxyAddress,
-      args.linkToken,
-      args.ccipRouter,
-      args.usdc,
-      args.owner,
-      args.poolMessengers,
-    ],
-    log: true,
-    autoMine: true,
-  })) as Deployment;
+    const deployChildPool = (await deploy("ConceroChildPool", {
+      from: deployer,
+      args: [
+        args.conceroProxyAddress,
+        args.childProxyAddress,
+        args.linkToken,
+        args.ccipRouter,
+        args.usdc,
+        args.owner,
+        args.poolMessengers,
+      ],
+      log: true,
+      autoMine: true,
+    })) as Deployment;
 
-  if (live) {
-    log(`ConceroChildPool deployed to ${name} to: ${deployChildPool.address}`, "deployConceroChildPool");
-    updateEnvVariable(`CHILD_POOL_${networkEnvKeys[name]}`, deployChildPool.address, `deployments.${type}`);
-  }
-};
+    if (live) {
+      log(`Deployed at: ${deployChildPool.address}`, "deployConceroChildPool", name);
+      updateEnvVariable(`CHILD_POOL_${networkEnvKeys[name]}`, deployChildPool.address, `deployments.${type}`);
+    }
+  };
 
 export default deployChildPool;
 deployChildPool.tags = ["ChildPool"];
diff --git a/packages/hardhat/deploy/09_ParentPool.ts b/packages/hardhat/deploy/09_ParentPool.ts
index f3638ed13..1c88c6167 100644
--- a/packages/hardhat/deploy/09_ParentPool.ts
+++ b/packages/hardhat/deploy/09_ParentPool.ts
@@ -1,4 +1,4 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import chains, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
@@ -10,74 +10,69 @@ interface ConstructorArgs {
   parentProxyAddress?: string;
   linkToken?: string;
   functionsDonId?: number;
-  functionsSubIds?: number;
+  functionsSubId?: number;
   functionsRouter?: string;
   ccipRouter?: string;
   usdc?: string;
   lpToken?: string;
-  automation?: string;
   conceroProxyAddress?: string;
   owner?: string;
   slotId?: number;
   poolMessengers?: string[];
 }
 
-const deployParentPool: DeployFunction = async function (
-  hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
-) {
-  const { deployer } = await hre.getNamedAccounts();
-  const { deploy } = hre.deployments;
-  const { name, live } = hre.network;
-  const networkType = chains[name].type;
-  const { linkToken, ccipRouter, functionsRouter, functionsDonId, functionsSubIds } = chains[name];
+const deployParentPool: (hre: HardhatRuntimeEnvironment, constructorArgs?: ConstructorArgs) => Promise<void> =
+  async function (hre: HardhatRuntimeEnvironment, constructorArgs: ConstructorArgs = {}) {
+    const { deployer } = await hre.getNamedAccounts();
+    const { deploy } = hre.deployments;
+    const { name, live } = hre.network;
+    const networkType = chains[name].type;
+    const { linkToken, ccipRouter, functionsRouter, functionsDonId, functionsSubIds } = chains[name];
 
-  const defaultArgs = {
-    parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
-    linkToken: linkToken,
-    functionsDonId: functionsDonId,
-    functionsSubId: functionsSubIds[0],
-    functionsRouter: functionsRouter,
-    ccipRouter: ccipRouter,
-    usdc: getEnvVar(`USDC_${networkEnvKeys[name]}`),
-    lpToken: getEnvVar(`LPTOKEN_${networkEnvKeys[name]}`),
-    automation: getEnvVar(`CONCERO_AUTOMATION_${networkEnvKeys[name]}`),
-    conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
-    owner: deployer,
-    slotid: 0,
-    poolMessengers,
-  };
+    const defaultArgs = {
+      parentProxyAddress: getEnvVar(`PARENT_POOL_PROXY_${networkEnvKeys[name]}`),
+      linkToken: linkToken,
+      functionsDonId: functionsDonId,
+      functionsSubId: functionsSubIds[0],
+      functionsRouter: functionsRouter,
+      ccipRouter: ccipRouter,
+      usdc: getEnvVar(`USDC_${networkEnvKeys[name]}`),
+      lpToken: getEnvVar(`LPTOKEN_${networkEnvKeys[name]}`),
+      conceroProxyAddress: getEnvVar(`CONCERO_INFRA_PROXY_${networkEnvKeys[name]}`),
+      owner: deployer,
+      slotid: 0,
+      poolMessengers,
+    };
 
-  // Merge defaultArgs with constructorArgs
-  const args = { ...defaultArgs, ...constructorArgs };
+    // Merge defaultArgs with constructorArgs
+    const args = { ...defaultArgs, ...constructorArgs };
 
-  console.log("Deploying ParentPool...");
-  const deployParentPool = (await deploy("ConceroParentPool", {
-    from: deployer,
-    args: [
-      args.parentProxyAddress,
-      args.linkToken,
-      args.functionsDonId,
-      args.functionsSubId,
-      args.functionsRouter,
-      args.ccipRouter,
-      args.usdc,
-      args.lpToken,
-      args.automation,
-      args.conceroProxyAddress,
-      args.owner,
-      args.slotId,
-      args.poolMessengers,
-    ],
-    log: true,
-    autoMine: true,
-  })) as Deployment;
+    log("Deploying...", "deployParentPool", name);
+    const deployParentPool = (await deploy("ConceroParentPool", {
+      from: deployer,
+      args: [
+        args.parentProxyAddress,
+        args.linkToken,
+        args.functionsDonId,
+        args.functionsSubId,
+        args.functionsRouter,
+        args.ccipRouter,
+        args.usdc,
+        args.lpToken,
+        args.conceroProxyAddress,
+        args.owner,
+        args.slotId,
+        args.poolMessengers,
+      ],
+      log: true,
+      autoMine: true,
+    })) as Deployment;
 
-  if (live) {
-    log(`ParentPool deployed to ${name} to: ${deployParentPool.address}`, "deployParentPool");
-    updateEnvVariable(`PARENT_POOL_${networkEnvKeys[name]}`, deployParentPool.address, `deployments.${networkType}`);
-  }
-};
+    if (live) {
+      log(`Deployed at: ${deployParentPool.address}`, "deployParentPool", name);
+      updateEnvVariable(`PARENT_POOL_${networkEnvKeys[name]}`, deployParentPool.address, `deployments.${networkType}`);
+    }
+  };
 
 export default deployParentPool;
 deployParentPool.tags = ["ParentPool"];
diff --git a/packages/hardhat/deploy/10_ConceroProxyAdmin.ts b/packages/hardhat/deploy/10_ConceroProxyAdmin.ts
index 75258c5eb..83f08a1d3 100644
--- a/packages/hardhat/deploy/10_ConceroProxyAdmin.ts
+++ b/packages/hardhat/deploy/10_ConceroProxyAdmin.ts
@@ -1,12 +1,15 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
-import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
-import updateEnvVariable from "../utils/updateEnvVariable";
+import CNetworks from "../constants/CNetworks";
+import { updateEnvAddress } from "../utils/updateEnvVariable";
 import log from "../utils/log";
 import { getEnvVar } from "../utils/getEnvVar";
-import { ProxyType } from "./11_TransparentProxy";
+import { ProxyType } from "../constants/deploymentVariables";
 
-const deployProxyAdmin: DeployFunction = async function (hre: HardhatRuntimeEnvironment, proxyType: ProxyType) {
+const deployProxyAdmin: (hre: HardhatRuntimeEnvironment, proxyType: ProxyType) => Promise<void> = async function (
+  hre: HardhatRuntimeEnvironment,
+  proxyType: ProxyType,
+) {
   const { proxyDeployer } = await hre.getNamedAccounts();
   const { deploy } = hre.deployments;
   const { name, live } = hre.network;
@@ -14,22 +17,7 @@ const deployProxyAdmin: DeployFunction = async function (hre: HardhatRuntimeEnvi
 
   const initialOwner = getEnvVar(`PROXY_DEPLOYER_ADDRESS`);
 
-  let envKey: string;
-  switch (proxyType) {
-    case ProxyType.infra:
-      envKey = `CONCERO_INFRA_PROXY`;
-      break;
-    case ProxyType.parentPool:
-      envKey = `PARENT_POOL_PROXY`;
-      break;
-    case ProxyType.childPool:
-      envKey = `CHILD_POOL_PROXY`;
-      break;
-    default:
-      throw new Error("Invalid ProxyType");
-  }
-
-  console.log("Deploying ProxyAdmin...");
+  log("Deploying...", `deployProxyAdmin: ${proxyType}`, name);
   const deployProxyAdmin = (await deploy("ConceroProxyAdmin", {
     from: proxyDeployer,
     args: [initialOwner],
@@ -38,12 +26,8 @@ const deployProxyAdmin: DeployFunction = async function (hre: HardhatRuntimeEnvi
   })) as Deployment;
 
   if (live) {
-    log(`ProxyAdmin deployed to ${name} to: ${deployProxyAdmin.address}`, "deployProxyAdmin");
-    updateEnvVariable(
-      `${envKey}_ADMIN_CONTRACT_${networkEnvKeys[name]}`,
-      deployProxyAdmin.address,
-      `deployments.${networkType}`,
-    );
+    log(`Deployed at: ${deployProxyAdmin.address}`, `deployProxyAdmin: ${proxyType}`, name);
+    updateEnvAddress(`${proxyType}Admin`, name, deployProxyAdmin.address, `deployments.${networkType}`);
   }
 };
 
diff --git a/packages/hardhat/deploy/11_TransparentProxy.ts b/packages/hardhat/deploy/11_TransparentProxy.ts
index 7ae477b30..85cff0b8a 100644
--- a/packages/hardhat/deploy/11_TransparentProxy.ts
+++ b/packages/hardhat/deploy/11_TransparentProxy.ts
@@ -1,59 +1,39 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
-import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
-import updateEnvVariable from "../utils/updateEnvVariable";
+import CNetworks from "../constants/CNetworks";
+import { updateEnvAddress } from "../utils/updateEnvVariable";
 import log from "../utils/log";
-import { getEnvVar } from "../utils/getEnvVar";
+import { getEnvAddress } from "../utils/getEnvVar";
+import { ProxyType } from "../constants/deploymentVariables";
 
-export enum ProxyType {
-  infra,
-  parentPool,
-  childPool,
-}
-const deployTransparentProxy: DeployFunction = async function (hre: HardhatRuntimeEnvironment, proxyType: ProxyType) {
+const deployTransparentProxy: (hre: HardhatRuntimeEnvironment, proxyType: ProxyType) => Promise<void> = async function (
+  hre: HardhatRuntimeEnvironment,
+  proxyType: ProxyType,
+) {
   const { proxyDeployer } = await hre.getNamedAccounts();
   const { deploy } = hre.deployments;
   const { name, live } = hre.network;
   const networkType = CNetworks[name].type;
 
-  let envKey: string;
+  const [initialImplementation, initialImplementationAlias] = getEnvAddress("pause", name);
+  const [proxyAdmin, proxyAdminAlias] = getEnvAddress(`${proxyType}Admin`, name);
 
-  switch (proxyType) {
-    case ProxyType.infra:
-      envKey = `CONCERO_INFRA_PROXY`;
-      break;
-    case ProxyType.parentPool:
-      envKey = `PARENT_POOL_PROXY`;
-      break;
-    case ProxyType.childPool:
-      envKey = `CHILD_POOL_PROXY`;
-      break;
-    default:
-      throw new Error("Invalid ProxyType");
-  }
-
-  const initialProxyImplementationAddress = getEnvVar(`CONCERO_PAUSE_${networkEnvKeys[name]}`);
-  const proxyAdminContract = getEnvVar(`${envKey}_ADMIN_CONTRACT_${networkEnvKeys[name]}`);
-
-  console.log("Deploying TransparentProxyInfra with args:", initialProxyImplementationAddress, proxyAdminContract);
+  log("Deploying...", `deployTransparentProxy:${proxyType}`, name);
 
   const conceroProxyDeployment = (await deploy("TransparentUpgradeableProxy", {
     from: proxyDeployer,
-    args: [initialProxyImplementationAddress, proxyAdminContract, "0x"],
+    args: [initialImplementation, proxyAdmin, "0x"],
     log: true,
     autoMine: true,
   })) as Deployment;
 
   if (live) {
     log(
-      `TransparentProxy ${envKey} deployed to ${name} to: ${conceroProxyDeployment.address}`,
-      "deployTransparentProxy",
-    );
-    updateEnvVariable(
-      `${envKey}_${networkEnvKeys[name]}`,
-      conceroProxyDeployment.address,
-      `deployments.${networkType}`,
+      `Deployed at: ${conceroProxyDeployment.address}. Initial impl: ${initialImplementationAlias}, Proxy admin: ${proxyAdminAlias}`,
+      `deployTransparentProxy: ${proxyType}`,
+      name,
     );
+    updateEnvAddress(proxyType, name, conceroProxyDeployment.address, `deployments.${networkType}`);
   }
 };
 
diff --git a/packages/hardhat/deploy/12_PauseDummy.ts b/packages/hardhat/deploy/12_PauseDummy.ts
index 6191f88c6..085c08352 100644
--- a/packages/hardhat/deploy/12_PauseDummy.ts
+++ b/packages/hardhat/deploy/12_PauseDummy.ts
@@ -1,19 +1,18 @@
-import { DeployFunction, Deployment } from "hardhat-deploy/types";
+import { Deployment } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import CNetworks, { networkEnvKeys } from "../constants/CNetworks";
 import updateEnvVariable from "../utils/updateEnvVariable";
 import log from "../utils/log";
 
-const deployPauseDummy: DeployFunction = async function (
+const deployPauseDummy: (hre: HardhatRuntimeEnvironment) => Promise<void> = async function (
   hre: HardhatRuntimeEnvironment,
-  constructorArgs: ConstructorArgs = {},
 ) {
   const { deployer } = await hre.getNamedAccounts();
   const { deploy } = hre.deployments;
   const { name, live } = hre.network;
   const networkType = CNetworks[name].type;
 
-  console.log("Deploying PauseDummy...");
+  console.log("Deploying...", "deployPauseDummy", name);
 
   const deployPauseDummy = (await deploy("PauseDummy", {
     from: deployer,
@@ -23,7 +22,7 @@ const deployPauseDummy: DeployFunction = async function (
   })) as Deployment;
 
   if (live) {
-    log(`PauseDummy deployed to ${name} to: ${deployPauseDummy.address}`, "deployPauseDummy");
+    log(`Deployed at: ${deployPauseDummy.address}`, "deployPauseDummy", name);
     updateEnvVariable(`CONCERO_PAUSE_${networkEnvKeys[name]}`, deployPauseDummy.address, `deployments.${networkType}`);
   }
 };
diff --git a/packages/hardhat/tasks/concero/deployInfra/deployInfra.ts b/packages/hardhat/tasks/concero/deployInfra/deployInfra.ts
index aaaa5fc02..5d0eb29a9 100644
--- a/packages/hardhat/tasks/concero/deployInfra/deployInfra.ts
+++ b/packages/hardhat/tasks/concero/deployInfra/deployInfra.ts
@@ -56,8 +56,8 @@ async function deployInfra(params: DeployInfraParams) {
 
   if (deployProxy) {
     await ensureWalletBalance(proxyDeployer, deployerTargetBalances, CNetworks[name]);
-    await deployProxyAdmin(hre, ProxyType.infra);
-    await deployTransparentProxy(hre, ProxyType.infra);
+    await deployProxyAdmin(hre, "infraProxy");
+    await deployTransparentProxy(hre, "infraProxy");
 
     const [proxyAddress, _] = getEnvAddress("infraProxy", name);
     const { functionsSubIds } = CNetworks[name];
@@ -70,7 +70,7 @@ async function deployInfra(params: DeployInfraParams) {
     await deployConceroDexSwap(hre);
     await deployConcero(hre, { slotId });
     await deployConceroOrchestrator(hre);
-    await upgradeProxyImplementation(hre, ProxyType.infra, false);
+    await upgradeProxyImplementation(hre, "infraProxy", false);
   }
 
   if (setVars) {
diff --git a/packages/hardhat/tasks/concero/deployPool/deployChildPool.ts b/packages/hardhat/tasks/concero/deployPool/deployChildPool.ts
index 69a370ffe..2b3373fc6 100644
--- a/packages/hardhat/tasks/concero/deployPool/deployChildPool.ts
+++ b/packages/hardhat/tasks/concero/deployPool/deployChildPool.ts
@@ -15,11 +15,10 @@ task("deploy-child-pool", "Deploy the pool")
   .setAction(async taskArgs => {
     const hre: HardhatRuntimeEnvironment = require("hardhat");
     const slotId = parseInt(taskArgs.slotid);
-    const { live } = hre.network;
 
     if (taskArgs.deployproxy) {
-      await deployProxyAdmin(hre, ProxyType.childPool);
-      await deployTransparentProxy(hre, ProxyType.childPool);
+      await deployProxyAdmin(hre, "childPoolProxy");
+      await deployTransparentProxy(hre, "childPoolProxy");
     }
 
     if (taskArgs.skipdeploy) {
diff --git a/packages/hardhat/tasks/concero/deployPool/deployParentPool.ts b/packages/hardhat/tasks/concero/deployPool/deployParentPool.ts
index 9e0f529df..8f3ba667b 100644
--- a/packages/hardhat/tasks/concero/deployPool/deployParentPool.ts
+++ b/packages/hardhat/tasks/concero/deployPool/deployParentPool.ts
@@ -8,7 +8,7 @@ import uploadDonSecrets from "../../donSecrets/upload";
 import { CNetwork } from "../../../types/CNetwork";
 import { setParentPoolVariables } from "./setParentPoolVariables";
 import deployParentPool from "../../../deploy/09_ParentPool";
-import deployTransparentProxy, { ProxyType } from "../../../deploy/11_TransparentProxy";
+import deployTransparentProxy from "../../../deploy/11_TransparentProxy";
 import { upgradeProxyImplementation } from "../upgradeProxyImplementation";
 import deployProxyAdmin from "../../../deploy/10_ConceroProxyAdmin";
 import { compileContracts } from "../../../utils/compileContracts";
@@ -28,8 +28,8 @@ task("deploy-parent-pool", "Deploy the pool")
     const deployableChains: CNetwork[] = [CNetworks[hre.network.name]];
 
     if (taskArgs.deployproxy) {
-      await deployProxyAdmin(hre, ProxyType.parentPool);
-      await deployTransparentProxy(hre, ProxyType.parentPool);
+      await deployProxyAdmin(hre, "parentPoolProxy");
+      await deployTransparentProxy(hre, "parentPoolProxy");
       const [proxyAddress, _] = getEnvAddress("parentPoolProxy", name);
       const { functionsSubIds } = chains[name];
       await addCLFConsumer(chains[name], [proxyAddress], functionsSubIds[0]);
@@ -37,7 +37,7 @@ task("deploy-parent-pool", "Deploy the pool")
 
     if (taskArgs.deployimplementation) {
       await deployParentPool(hre); //todo: not passing slotId to deployParentPool functions' constructor args
-      await upgradeProxyImplementation(hre, ProxyType.parentPool, false);
+      await upgradeProxyImplementation(hre, "parentPoolProxy", false);
     }
 
     if (taskArgs.uploadsecrets) {
diff --git a/packages/hardhat/tasks/concero/upgradeProxyImplementation.ts b/packages/hardhat/tasks/concero/upgradeProxyImplementation.ts
index 44705dec9..e4fef025c 100644
--- a/packages/hardhat/tasks/concero/upgradeProxyImplementation.ts
+++ b/packages/hardhat/tasks/concero/upgradeProxyImplementation.ts
@@ -1,58 +1,49 @@
-import { getEnvVar } from "../../utils/getEnvVar";
-import CNetworks, { networkEnvKeys } from "../../constants/CNetworks";
+import { getEnvAddress } from "../../utils/getEnvVar";
+import CNetworks from "../../constants/CNetworks";
 import { privateKeyToAccount } from "viem/accounts";
-import log from "../../utils/log";
+import log, { err } from "../../utils/log";
 import { task } from "hardhat/config";
-import { ProxyType } from "../../deploy/11_TransparentProxy";
 import { getFallbackClients } from "../utils/getViemClients";
-import { viemReceiptConfig } from "../../constants/deploymentVariables";
+import { DeploymentPrefixes, ProxyType, viemReceiptConfig } from "../../constants/deploymentVariables";
+import { formatGas } from "../../utils/formatting";
 
 export async function upgradeProxyImplementation(hre, proxyType: ProxyType, shouldPause: boolean) {
   const { name: chainName } = hre.network;
   const chainId = hre.network.config.chainId;
-  const { viemChain, url } = CNetworks[chainName];
+  const { viemChain } = CNetworks[chainName];
 
-  let envKey: string;
-  let implementationKey: string;
+  let implementationKey: keyof DeploymentPrefixes;
 
-  switch (proxyType) {
-    case ProxyType.infra:
-      envKey = `CONCERO_INFRA_PROXY`;
-      implementationKey = `CONCERO_ORCHESTRATOR`;
-      break;
-    case ProxyType.parentPool:
-      envKey = `PARENT_POOL_PROXY`;
-      implementationKey = `PARENT_POOL`;
-      break;
-    case ProxyType.childPool:
-      envKey = `CHILD_POOL_PROXY`;
-      implementationKey = `CHILD_POOL`;
-      break;
-    default:
-      throw new Error("Invalid ProxyType");
+  if (shouldPause) {
+    implementationKey = "pause";
+  } else if (proxyType === "infraProxy") {
+    implementationKey = "orchestrator";
+  } else if (proxyType === "childPoolProxy") {
+    implementationKey = "childPool";
+  } else if (proxyType === "parentPoolProxy") {
+    implementationKey = "parentPool";
+  } else {
+    err(`Proxy type ${proxyType} not found`, "upgradeProxyImplementation", chainName);
+    return;
   }
 
   const { abi: proxyAdminAbi } = await import(
     "../../artifacts/contracts/transparentProxy/ConceroProxyAdmin.sol/ConceroProxyAdmin.json"
   );
 
-  if (!viemChain) {
-    log(`Chain ${chainId} not found in live chains`, "upgradeProxyImplementation");
-    return;
-  }
-
   const viemAccount = privateKeyToAccount(`0x${process.env.PROXY_DEPLOYER_PRIVATE_KEY}`);
   const { walletClient, publicClient } = getFallbackClients(CNetworks[chainName], viemAccount);
 
-  const conceroProxy = getEnvVar(`${envKey}_${networkEnvKeys[chainName]}`);
-  const proxyAdminContract = getEnvVar(`${envKey}_ADMIN_CONTRACT_${networkEnvKeys[chainName]}`);
-  const newImplementationAddress = getEnvVar(`${implementationKey}_${networkEnvKeys[chainName]}`);
-  const pauseDummy = getEnvVar(`CONCERO_PAUSE_${networkEnvKeys[chainName]}`);
+  const [conceroProxy, conceroProxyAlias] = getEnvAddress(proxyType, chainName);
+  const [proxyAdmin, proxyAdminAlias] = getEnvAddress(`${proxyType}Admin`, chainName);
+  const [newImplementation, newImplementationAlias] = getEnvAddress(implementationKey, chainName);
+  const [pauseDummy, pauseAlias] = getEnvAddress("pause", chainName);
 
-  const implementation = shouldPause ? pauseDummy : newImplementationAddress;
+  const implementation = shouldPause ? pauseDummy : newImplementation;
+  const implementationAlias = shouldPause ? pauseAlias : newImplementationAlias;
 
   const txHash = await walletClient.writeContract({
-    address: proxyAdminContract,
+    address: proxyAdmin,
     abi: proxyAdminAbi,
     functionName: "upgradeAndCall",
     account: viemAccount,
@@ -63,8 +54,8 @@ export async function upgradeProxyImplementation(hre, proxyType: ProxyType, shou
   const { cumulativeGasUsed } = await publicClient.waitForTransactionReceipt({ ...viemReceiptConfig, hash: txHash });
 
   log(
-    `Upgrade Proxy Implementation: gasUsed: ${cumulativeGasUsed}, hash: ${txHash}`,
-    "setProxyImplementation",
+    `Upgraded via ${proxyAdminAlias}: ${conceroProxyAlias}.implementation -> ${implementationAlias}. Gas : ${formatGas(cumulativeGasUsed)}, hash: ${txHash}`,
+    `setProxyImplementation : ${proxyType}`,
     chainName,
   );
 }
@@ -72,10 +63,7 @@ export default {};
 
 task("upgrade-proxy-implementation", "Upgrades the proxy implementation")
   .addFlag("pause", "Pause the proxy before upgrading", false)
-  .addParam("proxytype", "The type of the proxy to upgrade")
+  .addParam("proxytype", "The type of the proxy to upgrade", undefined)
   .setAction(async taskArgs => {
-    const { name, live } = hre.network;
-    if (live) {
-      await upgradeProxyImplementation(hre, parseInt(taskArgs.proxytype), taskArgs.pause);
-    }
+    await upgradeProxyImplementation(hre, taskArgs.proxytype, taskArgs.pause);
   });
diff --git a/packages/hardhat/tasks/sub/add.ts b/packages/hardhat/tasks/sub/add.ts
index e6777b7d7..41c9b5b18 100644
--- a/packages/hardhat/tasks/sub/add.ts
+++ b/packages/hardhat/tasks/sub/add.ts
@@ -6,6 +6,7 @@ import { CNetwork } from "../../types/CNetwork";
 
 import log, { err, warn } from "../../utils/log";
 import { Address } from "viem";
+import { shorten } from "../../utils/formatting";
 
 // run with: bunx hardhat clf-consumer-add --subid 5810 --contract 0x... --network avalancheFuji
 task("clf-sub-consumer-add", "Adds a consumer contract to the Functions billing subscription")
@@ -15,7 +16,6 @@ task("clf-sub-consumer-add", "Adds a consumer contract to the Functions billing
     const hre: HardhatRuntimeEnvironment = require("hardhat");
     const { name, live } = hre.network;
     if (!chains[name]) throw new Error(`Chain ${name} not supported`);
-    const consumerAddress = taskArgs.contract;
     let subscriptionId;
     if (!taskArgs.subid) {
       warn(`No subscription ID provided, defaulting to ${chains[name].functionsSubIds[0]}`, "addCLFConsumer", name);
@@ -31,7 +31,7 @@ async function addCLFConsumer(chain: CNetwork, consumerAddresses: Address[], sub
   const signer = await hre.ethers.getSigner(process.env.DEPLOYER_ADDRESS);
   for (const consumerAddress of consumerAddresses) {
     const txOptions = { confirmations };
-    log(`Adding ${consumerAddress} to sub ${subscriptionId} on ${name}`, "addCLFConsumer");
+    log(`Adding ${shorten(consumerAddress)} to sub ${subscriptionId}`, "addCLFConsumer", name);
 
     const sm = new SubscriptionManager({
       signer,
diff --git a/packages/hardhat/utils/updateEnvVariable.ts b/packages/hardhat/utils/updateEnvVariable.ts
index 68b00a4c3..52bec8fdf 100644
--- a/packages/hardhat/utils/updateEnvVariable.ts
+++ b/packages/hardhat/utils/updateEnvVariable.ts
@@ -1,6 +1,9 @@
 import { readFileSync, writeFileSync } from "fs";
 import path from "path";
 import log from "./log";
+import { deploymentPrefixes, DeploymentPrefixes } from "../constants/deploymentVariables";
+import { CNetworkNames } from "../types/CNetwork";
+import { networkEnvKeys } from "../constants/CNetworks";
 
 /**
  * Update an environment variable in the .env file
@@ -35,4 +38,17 @@ function updateEnvVariable(key: string, newValue: string, envFileName: EnvFileNa
   process.env[key] = newValue;
 }
 
+export function updateEnvAddress(
+  prefix: keyof DeploymentPrefixes,
+  networkPostfix?: CNetworkNames | string,
+  newValue: string,
+  envFileName: EnvFileName,
+): void {
+  const searchKey = networkPostfix
+    ? `${deploymentPrefixes[prefix]}_${networkEnvKeys[networkPostfix]}`
+    : deploymentPrefixes[prefix];
+
+  updateEnvVariable(searchKey, newValue, envFileName);
+}
+
 export default updateEnvVariable;