diff --git a/.npmrc b/.npmrc
new file mode 100644
index 0000000..af66bba
--- /dev/null
+++ b/.npmrc
@@ -0,0 +1 @@
+@angleprotocol:registry=https://npm.pkg.github.com
diff --git a/foundry.toml b/foundry.toml
index 25b918f..ced923e 100644
--- a/foundry.toml
+++ b/foundry.toml
@@ -2,5 +2,6 @@
 src = "src"
 out = "out"
 libs = ["lib"]
+fs_permissions = [{ access = "read", path = "./node_modules/@angleprotocol/sdk/dist/src/registry/registry.json" }]
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
diff --git a/package.json b/package.json
index d4abf41..e7514da 100644
--- a/package.json
+++ b/package.json
@@ -5,6 +5,6 @@
   "author": "Angle Labs, Inc.",
   "license": "GPL-3.0",
   "dependencies": {
-    "@angleprotocol/sdk": "^0.37.1"
+    "@angleprotocol/sdk": "^2.34.7"
   }
 }
\ No newline at end of file
diff --git a/src/CommonUtils.sol b/src/CommonUtils.sol
index db967cb..2fef51b 100644
--- a/src/CommonUtils.sol
+++ b/src/CommonUtils.sol
@@ -3,13 +3,17 @@ pragma solidity ^0.8.0;
 
 import {ILayerZeroEndpoint} from "lz/lzApp/interfaces/ILayerZeroEndpoint.sol";
 import {TransparentUpgradeableProxy} from "oz/proxy/transparent/TransparentUpgradeableProxy.sol";
-import "forge-std/Base.sol";
-import "stringutils/strings.sol";
+import {CommonBase, VmSafe} from "forge-std/Base.sol";
 
-import "../src/Constants.sol";
+import {JsonReader} from "./JsonReader.sol";
+import {strings} from "stringutils/strings.sol";
+import {ContractType, Constants} from "./Constants.sol";
 
-contract CommonUtils is CommonBase {
+contract CommonUtils is CommonBase, JsonReader {
     using strings for *;
+    bytes32 private constant EUR_HASH = keccak256(abi.encodePacked("EUR"));
+    bytes32 private constant USD_HASH = keccak256(abi.encodePacked("USD"));
+    bytes32 private constant ANGLE_HASH = keccak256(abi.encodePacked("ANGLE"));
 
     mapping(uint256 => uint256) internal forkIdentifier;
     uint256 public arbitrumFork;
@@ -28,75 +32,192 @@ contract CommonUtils is CommonBase {
     uint256 public blastFork;
     uint256 public xlayerFork;
     uint256 public chainFork;
+    uint256 public fantomFork;
+    uint256 public auroraFork;
+    uint256 public thunderCoreFork;
+    uint256 public coreDaoFork;
+    uint256 public taikoFork;
+    uint256 public fuseFork;
+    uint256 public immutableFork;
+    uint256 public scrollFork;
+    uint256 public mantaFork;
+    uint256 public seiFork;
+    uint256 public fraxtalFork;
+    uint256 public astarFork;
+    uint256 public astarZkEVMFork;
+    uint256 public rootstockFork;
+    uint256 public moonbeamFork;
+    uint256 public skaleFork;
+    uint256 public worldchainFork;
+    uint256 public liskFork;
+    uint256 public etherlinkFork;
+    uint256 public artheraFork;
+    uint256 public swellFork;
 
     function setUpForks() public virtual {
         if (vm.envExists("ETH_NODE_URI_ARBITRUM")) {
             arbitrumFork = vm.createFork(vm.envString("ETH_NODE_URI_ARBITRUM"));
-            forkIdentifier[CHAIN_ARBITRUM] = arbitrumFork;
+            forkIdentifier[Constants.CHAIN_ARBITRUM] = arbitrumFork;
         }
         if (vm.envExists("ETH_NODE_URI_AVALANCHE")) {
             avalancheFork = vm.createFork(
                 vm.envString("ETH_NODE_URI_AVALANCHE")
             );
-            forkIdentifier[CHAIN_AVALANCHE] = avalancheFork;
+            forkIdentifier[Constants.CHAIN_AVALANCHE] = avalancheFork;
         }
         if (vm.envExists("ETH_NODE_URI_MAINNET")) {
             ethereumFork = vm.createFork(vm.envString("ETH_NODE_URI_MAINNET"));
-            forkIdentifier[CHAIN_ETHEREUM] = ethereumFork;
+            forkIdentifier[Constants.CHAIN_ETHEREUM] = ethereumFork;
         }
         if (vm.envExists("ETH_NODE_URI_OPTIMISM")) {
             optimismFork = vm.createFork(vm.envString("ETH_NODE_URI_OPTIMISM"));
-            forkIdentifier[CHAIN_OPTIMISM] = optimismFork;
+            forkIdentifier[Constants.CHAIN_OPTIMISM] = optimismFork;
         }
         if (vm.envExists("ETH_NODE_URI_POLYGON")) {
             polygonFork = vm.createFork(vm.envString("ETH_NODE_URI_POLYGON"));
-            forkIdentifier[CHAIN_POLYGON] = polygonFork;
+            forkIdentifier[Constants.CHAIN_POLYGON] = polygonFork;
         }
         if (vm.envExists("ETH_NODE_URI_GNOSIS")) {
             gnosisFork = vm.createFork(vm.envString("ETH_NODE_URI_GNOSIS"));
-            forkIdentifier[CHAIN_GNOSIS] = gnosisFork;
+            forkIdentifier[Constants.CHAIN_GNOSIS] = gnosisFork;
         }
         if (vm.envExists("ETH_NODE_URI_BSC")) {
             bnbFork = vm.createFork(vm.envString("ETH_NODE_URI_BSC"));
-            forkIdentifier[CHAIN_BNB] = bnbFork;
+            forkIdentifier[Constants.CHAIN_BNB] = bnbFork;
         }
         if (vm.envExists("ETH_NODE_URI_CELO")) {
             celoFork = vm.createFork(vm.envString("ETH_NODE_URI_CELO"));
-            forkIdentifier[CHAIN_CELO] = celoFork;
+            forkIdentifier[Constants.CHAIN_CELO] = celoFork;
         }
         if (vm.envExists("ETH_NODE_URI_POLYGON_ZKEVM")) {
             polygonZkEVMFork = vm.createFork(
                 vm.envString("ETH_NODE_URI_POLYGON_ZKEVM")
             );
-            forkIdentifier[CHAIN_POLYGONZKEVM] = polygonZkEVMFork;
+            forkIdentifier[Constants.CHAIN_POLYGONZKEVM] = polygonZkEVMFork;
         }
         if (vm.envExists("ETH_NODE_URI_BASE")) {
             baseFork = vm.createFork(vm.envString("ETH_NODE_URI_BASE"));
-            forkIdentifier[CHAIN_BASE] = baseFork;
+            forkIdentifier[Constants.CHAIN_BASE] = baseFork;
         }
         if (vm.envExists("ETH_NODE_URI_LINEA")) {
             lineaFork = vm.createFork(vm.envString("ETH_NODE_URI_LINEA"));
-            forkIdentifier[CHAIN_LINEA] = lineaFork;
+            forkIdentifier[Constants.CHAIN_LINEA] = lineaFork;
         }
         if (vm.envExists("ETH_NODE_URI_MANTLE")) {
             mantleFork = vm.createFork(vm.envString("ETH_NODE_URI_MANTLE"));
-            forkIdentifier[CHAIN_MANTLE] = mantleFork;
+            forkIdentifier[Constants.CHAIN_MANTLE] = mantleFork;
         }
         if (vm.envExists("ETH_NODE_URI_MODE")) {
             modeFork = vm.createFork(vm.envString("ETH_NODE_URI_MODE"));
-            forkIdentifier[CHAIN_MODE] = modeFork;
+            forkIdentifier[Constants.CHAIN_MODE] = modeFork;
         }
         if (vm.envExists("ETH_NODE_URI_BLAST")) {
             blastFork = vm.createFork(vm.envString("ETH_NODE_URI_BLAST"));
-            forkIdentifier[CHAIN_BLAST] = blastFork;
+            forkIdentifier[Constants.CHAIN_BLAST] = blastFork;
         }
         if (vm.envExists("ETH_NODE_URI_XLAYER")) {
             xlayerFork = vm.createFork(vm.envString("ETH_NODE_URI_XLAYER"));
-            forkIdentifier[CHAIN_XLAYER] = xlayerFork;
+            forkIdentifier[Constants.CHAIN_XLAYER] = xlayerFork;
         }
         if (vm.envExists("ETH_NODE_URI_FORK")) {
             chainFork = vm.createFork(vm.envString("ETH_NODE_URI_FORK"));
-            forkIdentifier[CHAIN_FORK] = chainFork;
+            forkIdentifier[Constants.CHAIN_FORK] = chainFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_FANTOM")) {
+            fantomFork = vm.createFork(vm.envString("ETH_NODE_URI_FANTOM"));
+            forkIdentifier[Constants.CHAIN_FANTOM] = fantomFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_AURORA")) {
+            auroraFork = vm.createFork(vm.envString("ETH_NODE_URI_AURORA"));
+            forkIdentifier[Constants.CHAIN_AURORA] = auroraFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_THUNDERCORE")) {
+            thunderCoreFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_THUNDERCORE")
+            );
+            forkIdentifier[Constants.CHAIN_THUNDERCORE] = thunderCoreFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_COREDAO")) {
+            coreDaoFork = vm.createFork(vm.envString("ETH_NODE_URI_COREDAO"));
+            forkIdentifier[Constants.CHAIN_COREDAO] = coreDaoFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_TAIKO")) {
+            taikoFork = vm.createFork(vm.envString("ETH_NODE_URI_TAIKO"));
+            forkIdentifier[Constants.CHAIN_TAIKO] = taikoFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_FUSE")) {
+            fuseFork = vm.createFork(vm.envString("ETH_NODE_URI_FUSE"));
+            forkIdentifier[Constants.CHAIN_FUSE] = fuseFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_IMMUTABLE")) {
+            immutableFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_IMMUTABLE")
+            );
+            forkIdentifier[Constants.CHAIN_IMMUTABLE] = immutableFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_SCROLL")) {
+            scrollFork = vm.createFork(vm.envString("ETH_NODE_URI_SCROLL"));
+            forkIdentifier[Constants.CHAIN_SCROLL] = scrollFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_MANTA")) {
+            mantaFork = vm.createFork(vm.envString("ETH_NODE_URI_MANTA"));
+            forkIdentifier[Constants.CHAIN_MANTA] = mantaFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_SEI")) {
+            seiFork = vm.createFork(vm.envString("ETH_NODE_URI_SEI"));
+            forkIdentifier[Constants.CHAIN_SEI] = seiFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_FRAXTAL")) {
+            fraxtalFork = vm.createFork(vm.envString("ETH_NODE_URI_FRAXTAL"));
+            forkIdentifier[Constants.CHAIN_FRAXTAL] = fraxtalFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_ASTAR")) {
+            astarFork = vm.createFork(vm.envString("ETH_NODE_URI_ASTAR"));
+            forkIdentifier[Constants.CHAIN_ASTAR] = astarFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_ASTARZKEVM")) {
+            astarZkEVMFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_ASTARZKEVM")
+            );
+            forkIdentifier[Constants.CHAIN_ASTARZKEVM] = astarZkEVMFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_ROOTSTOCK")) {
+            rootstockFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_ROOTSTOCK")
+            );
+            forkIdentifier[Constants.CHAIN_ROOTSTOCK] = rootstockFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_MOONBEAM")) {
+            moonbeamFork = vm.createFork(vm.envString("ETH_NODE_URI_MOONBEAM"));
+            forkIdentifier[Constants.CHAIN_MOONBEAM] = moonbeamFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_SKALE")) {
+            skaleFork = vm.createFork(vm.envString("ETH_NODE_URI_SKALE"));
+            forkIdentifier[Constants.CHAIN_SKALE] = skaleFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_WORLDCHAIN")) {
+            worldchainFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_WORLDCHAIN")
+            );
+            forkIdentifier[Constants.CHAIN_WORLDCHAIN] = worldchainFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_LISK")) {
+            liskFork = vm.createFork(vm.envString("ETH_NODE_URI_LISK"));
+            forkIdentifier[Constants.CHAIN_LISK] = liskFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_ETHERLINK")) {
+            etherlinkFork = vm.createFork(
+                vm.envString("ETH_NODE_URI_ETHERLINK")
+            );
+            forkIdentifier[Constants.CHAIN_ETHERLINK] = etherlinkFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_ARTHERA")) {
+            artheraFork = vm.createFork(vm.envString("ETH_NODE_URI_ARTHERA"));
+            forkIdentifier[Constants.CHAIN_ARTHERA] = artheraFork;
+        }
+        if (vm.envExists("ETH_NODE_URI_SWELL")) {
+            swellFork = vm.createFork(vm.envString("ETH_NODE_URI_SWELL"));
+            forkIdentifier[Constants.CHAIN_SWELL] = swellFork;
         }
     }
 
@@ -104,25 +225,25 @@ contract CommonUtils is CommonBase {
         uint256 chainId
     ) internal returns (ILayerZeroEndpoint) {
         // TODO temporary check if LZ updated their sdk
-        if (chainId == CHAIN_GNOSIS) {
+        if (chainId == Constants.CHAIN_GNOSIS) {
             return
                 ILayerZeroEndpoint(0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4);
-        } else if (chainId == CHAIN_POLYGONZKEVM) {
+        } else if (chainId == Constants.CHAIN_POLYGONZKEVM) {
             return
                 ILayerZeroEndpoint(0x9740FF91F1985D8d2B71494aE1A2f723bb3Ed9E4);
-        } else if (chainId == CHAIN_BASE) {
+        } else if (chainId == Constants.CHAIN_BASE) {
             return
                 ILayerZeroEndpoint(0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7);
-        } else if (chainId == CHAIN_CELO) {
+        } else if (chainId == Constants.CHAIN_CELO) {
             return
                 ILayerZeroEndpoint(0x3A73033C0b1407574C76BdBAc67f126f6b4a9AA9);
-        } else if (chainId == CHAIN_LINEA) {
+        } else if (chainId == Constants.CHAIN_LINEA) {
             return
                 ILayerZeroEndpoint(0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7);
-        } else if (chainId == CHAIN_BLAST) {
+        } else if (chainId == Constants.CHAIN_BLAST) {
             return
                 ILayerZeroEndpoint(0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7);
-        } else if (chainId == CHAIN_XLAYER) {
+        } else if (chainId == Constants.CHAIN_XLAYER) {
             return
                 ILayerZeroEndpoint(0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7);
         }
@@ -140,102 +261,274 @@ contract CommonUtils is CommonBase {
 
     function _getAllContracts(
         uint256 chainId
-    ) internal returns (address[] memory allContracts) {
-        string[] memory cmd = new string[](4);
-        cmd[0] = "node";
-        cmd[1] = "utils/forwardUtils.js";
-        cmd[2] = "getAllContracts";
-        cmd[3] = vm.toString(chainId);
+    ) internal view returns (address[] memory) {
+        string memory json = readJsonFile(getPath());
+
+        // Get all keys at the chain level (these are the contract categories)
+        string memory chainPath = string.concat(".", vm.toString(chainId));
+        string[] memory keys = vm.parseJsonKeys(json, chainPath);
+
+        // Create dynamic arrays to store addresses
+        address[] memory addresses = new address[](100); // Initial size
+        uint256 count = 0;
+
+        // Iterate through each key to collect addresses
+        for (uint256 i = 0; i < keys.length; i++) {
+            string memory key = keys[i];
+            string memory fullPath = string.concat(chainPath, ".", key);
+
+            // Try to parse as direct address
+            try vm.parseJsonAddress(json, fullPath) returns (address addr) {
+                if (addr != address(0)) {
+                    addresses[count++] = addr;
+                }
+            } catch {
+                // If not a direct address, try to parse nested objects
+                try vm.parseJsonKeys(json, fullPath) returns (
+                    string[] memory subKeys
+                ) {
+                    for (uint256 j = 0; j < subKeys.length; j++) {
+                        string memory subPath = string.concat(
+                            fullPath,
+                            ".",
+                            subKeys[j]
+                        );
+                        try vm.parseJsonAddress(json, subPath) returns (
+                            address addr
+                        ) {
+                            if (addr != address(0)) {
+                                addresses[count++] = addr;
+                            }
+                        } catch {}
+                    }
+                } catch {}
+            }
+        }
 
-        VmSafe.FfiResult memory res = vm.tryFfi(cmd);
-        if (res.exitCode != 0) revert("Chain not supported");
-        allContracts = abi.decode(res.stdout, (address[]));
+        // Create final array with exact size
+        address[] memory result = new address[](count);
+        for (uint256 i = 0; i < count; i++) {
+            result[i] = addresses[i];
+        }
+
+        return result;
     }
 
     function _getConnectedChains(
         string memory token
     ) internal returns (uint256[] memory, address[] memory) {
-        string[] memory cmd = new string[](4);
-        cmd[0] = "node";
-        cmd[1] = "utils/forwardUtils.js";
-        cmd[2] = "getConnectedChains";
-        cmd[3] = token;
+        uint256[] memory allChainIds = _getChainIds();
+        uint256[] memory chainIds = new uint256[](0);
+        address[] memory contracts = new address[](0);
+
+        for (uint256 i = 0; i < allChainIds.length; i++) {
+            address addr;
+            if (keccak256(abi.encodePacked(token)) == EUR_HASH) {
+                try
+                    this.chainToContract(allChainIds[i], ContractType.AgEURLZ)
+                returns (address _addr) {
+                    addr = _addr;
+                } catch {}
+            } else if (keccak256(abi.encodePacked(token)) == USD_HASH) {
+                try
+                    this.chainToContract(allChainIds[i], ContractType.AgUSDLZ)
+                returns (address _addr) {
+                    addr = _addr;
+                } catch {}
+            } else if (keccak256(abi.encodePacked(token)) == ANGLE_HASH) {
+                try
+                    this.chainToContract(allChainIds[i], ContractType.AngleLZ)
+                returns (address _addr) {
+                    addr = _addr;
+                } catch {}
+            }
 
-        VmSafe.FfiResult memory res = vm.tryFfi(cmd);
-        if (res.exitCode != 0) revert("Chain not supported");
-        address[] memory contracts = vm.parseJsonAddressArray(
-            string(res.stdout),
-            ".contracts"
-        );
-        uint256[] memory chains = vm.parseJsonUintArray(
-            string(res.stdout),
-            ".chains"
-        );
-        return (chains, contracts);
+            if (addr != address(0)) {
+                assembly {
+                    // Get the current length of the arrays
+                    let oldLen := mload(chainIds)
+                    let newLen := add(oldLen, 1)
+
+                    // Calculate new memory locations
+                    let newChainIds := add(mload(0x40), 0x20)
+                    let newContracts := add(
+                        newChainIds,
+                        mul(add(newLen, 1), 0x20)
+                    )
+
+                    // Store lengths
+                    mstore(newChainIds, newLen)
+                    mstore(newContracts, newLen)
+
+                    // Copy existing chainIds
+                    let srcChainIds := add(chainIds, 0x20)
+                    let destChainIds := add(newChainIds, 0x20)
+                    for {
+                        let j := 0
+                    } lt(j, oldLen) {
+                        j := add(j, 1)
+                    } {
+                        mstore(
+                            add(destChainIds, mul(j, 0x20)),
+                            mload(add(srcChainIds, mul(j, 0x20)))
+                        )
+                    }
+
+                    // Copy existing contracts
+                    let srcContracts := add(contracts, 0x20)
+                    let destContracts := add(newContracts, 0x20)
+                    for {
+                        let j := 0
+                    } lt(j, oldLen) {
+                        j := add(j, 1)
+                    } {
+                        mstore(
+                            add(destContracts, mul(j, 0x20)),
+                            mload(add(srcContracts, mul(j, 0x20)))
+                        )
+                    }
+
+                    // Add new elements
+                    mstore(
+                        add(destChainIds, mul(oldLen, 0x20)),
+                        mload(add(allChainIds, add(0x20, mul(i, 0x20))))
+                    )
+                    mstore(add(destContracts, mul(oldLen, 0x20)), addr)
+
+                    // Update free memory pointer
+                    mstore(0x40, add(newContracts, mul(add(newLen, 1), 0x20)))
+
+                    // Update array pointers
+                    chainIds := newChainIds
+                    contracts := newContracts
+                }
+            }
+        }
+
+        return (chainIds, contracts);
+    }
+
+    /// @notice Get all chains from the SDK
+    function _getChainIds() internal view returns (uint256[] memory) {
+        // Parse the entire JSON object first
+        string memory json = readJsonFile(getPath());
+
+        // Get the object keys (chain IDs) at the root level
+        string[] memory chainIds = vm.parseJsonKeys(json, ".");
+
+        // Convert string array of chain IDs to uint256 array
+        uint256[] memory result = new uint256[](chainIds.length);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            result[i] = vm.parseUint(chainIds[i]);
+        }
+
+        return result;
+    }
+
+    /// @notice Get all chains where a specific contract type is deployed
+    function _getChainIdsWithDeployedContract(
+        ContractType contractType
+    ) internal view returns (uint256[] memory deployedChains) {
+        string memory json = readJsonFile(getPath());
+        string[] memory chainIds = vm.parseJsonKeys(json, ".");
+
+        // First count how many chains have the contract deployed
+        uint256 deployedCount = 0;
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            try this.chainToContract(vm.parseUint(chainIds[i]), contractType) {
+                deployedCount++;
+            } catch {
+                continue;
+            }
+        }
+
+        // Create array of exact size and populate it
+        deployedChains = new uint256[](deployedCount);
+        uint256 currentIndex = 0;
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            try this.chainToContract(vm.parseUint(chainIds[i]), contractType) {
+                deployedChains[currentIndex] = vm.parseUint(chainIds[i]);
+                currentIndex++;
+            } catch {
+                continue;
+            }
+        }
+    }
+
+    function chainToContract(
+        uint256 chainId,
+        ContractType name
+    ) external view returns (address) {
+        return _chainToContract(chainId, name);
     }
 
     function _chainToContract(
         uint256 chainId,
         ContractType name
-    ) internal returns (address) {
-        string[] memory cmd = new string[](5);
-        cmd[0] = "node";
-        cmd[1] = "utils/forwardUtils.js";
-        cmd[2] = "contractAddress";
-        cmd[3] = vm.toString(chainId);
+    ) internal view returns (address) {
+        return this.readAddress(chainId, _getContractPath(name));
+    }
 
-        if (name == ContractType.AgEUR) cmd[4] = "agEUR";
-        else if (name == ContractType.AgUSD) cmd[4] = "agUSD";
-        else if (name == ContractType.AgEURLZ) cmd[4] = "agEURLz";
-        else if (name == ContractType.AgUSDLZ) cmd[4] = "agUSDLz";
-        else if (name == ContractType.Angle) cmd[4] = "angle";
-        else if (name == ContractType.AngleLZ) cmd[4] = "angleLz";
+    /// @dev Helper function to get the JSON path for a contract type
+    function _getContractPath(
+        ContractType name
+    ) internal pure returns (string memory) {
+        if (name == ContractType.AgEUR) return "EUR.AgToken";
+        else if (name == ContractType.AgUSD) return "USD.AgToken";
+        else if (name == ContractType.AgEURLZ) return "EUR.bridges.LayerZero";
+        else if (name == ContractType.AgUSDLZ) return "USD.bridges.LayerZero";
+        else if (name == ContractType.Angle) return "ANGLE";
+        else if (name == ContractType.AngleLZ) return "bridges.LayerZero";
         else if (name == ContractType.AngleDistributor)
-            cmd[4] = "angleDistributor";
-        else if (name == ContractType.AngleMiddleman) cmd[4] = "angleMiddleman";
-        else if (name == ContractType.AngleRouter) cmd[4] = "angleRouter";
-        else if (name == ContractType.CoreBorrow) cmd[4] = "coreBorrow";
-        else if (name == ContractType.CoreMerkl) cmd[4] = "coreMerkl";
+            return "AngleDistributor";
+        else if (name == ContractType.AngleMiddleman) return "Middleman";
+        else if (name == ContractType.AngleRouter) return "AngleRouterV2";
+        else if (name == ContractType.CoreBorrow) return "CoreBorrow";
+        else if (name == ContractType.CoreMerkl) return "Merkl.CoreMerkl";
+        else if (name == ContractType.Disputer) return "Merkl.Disputer";
         else if (name == ContractType.DistributionCreator)
-            cmd[4] = "distributionCreator";
-        else if (name == ContractType.Distributor) cmd[4] = "distributor";
-        else if (name == ContractType.FeeDistributor) cmd[4] = "feeDistributor";
-        else if (name == ContractType.GaugeController)
-            cmd[4] = "gaugeController";
-        else if (name == ContractType.Governor) cmd[4] = "governor";
-        else if (name == ContractType.GovernorMultisig)
-            cmd[4] = "governorMultisig";
-        else if (name == ContractType.GuardianMultisig)
-            cmd[4] = "guardianMultisig";
-        else if (name == ContractType.MerklMiddleman) cmd[4] = "merklMiddleman";
+            return "Merkl.DistributionCreator";
+        else if (name == ContractType.Distributor) return "Merkl.Distributor";
+        else if (name == ContractType.FeeDistributor)
+            return "FeeDistributor_sanUSDC_EUR";
+        else if (name == ContractType.GaugeController) return "GaugeController";
+        else if (name == ContractType.Governor) return "AngleGovernor";
+        else if (name == ContractType.GovernorMultisig) return "Governor";
+        else if (name == ContractType.GuardianMultisig) return "Guardian";
+        else if (name == ContractType.MerklMiddleman)
+            return "MerklGaugeMiddleman";
         else if (name == ContractType.ProposalReceiver)
-            cmd[4] = "proposalReceiver";
-        else if (name == ContractType.ProposalSender) cmd[4] = "proposalSender";
-        else if (name == ContractType.ProxyAdmin) cmd[4] = "proxyAdmin";
+            return "ProposalReceiver";
+        else if (name == ContractType.ProposalSender) return "ProposalSender";
+        else if (name == ContractType.ProxyAdmin) return "ProxyAdmin";
         else if (name == ContractType.SmartWalletWhitelist)
-            cmd[4] = "smartWalletWhitelist";
-        else if (name == ContractType.StEUR) cmd[4] = "stEUR";
-        else if (name == ContractType.StUSD) cmd[4] = "stUSD";
-        else if (name == ContractType.Timelock) cmd[4] = "timelock";
-        else if (name == ContractType.TransmuterAgEUR)
-            cmd[4] = "transmuterAgEUR";
-        else if (name == ContractType.TransmuterAgUSD)
-            cmd[4] = "transmuterAgUSD";
-        else if (name == ContractType.TreasuryAgEUR) cmd[4] = "treasuryAgEUR";
-        else if (name == ContractType.TreasuryAgUSD) cmd[4] = "treasuryAgUSD";
-        else if (name == ContractType.veANGLE) cmd[4] = "veANGLE";
-        else if (name == ContractType.veBoost) cmd[4] = "veBoost";
-        else if (name == ContractType.veBoostProxy) cmd[4] = "veBoostProxy";
+            return "SmartWalletWhitelist";
+        else if (name == ContractType.StEUR) return "EUR.Savings";
+        else if (name == ContractType.StUSD) return "USD.Savings";
+        else if (name == ContractType.Timelock) return "Timelock";
+        else if (name == ContractType.TransmuterAgEUR) return "EUR.Transmuter";
+        else if (name == ContractType.TransmuterAgUSD) return "USD.Transmuter";
+        else if (name == ContractType.TreasuryAgEUR) return "EUR.Treasury";
+        else if (name == ContractType.TreasuryAgUSD) return "USD.Treasury";
+        else if (name == ContractType.veANGLE) return "veANGLE";
+        else if (name == ContractType.veBoost) return "veBoost";
+        else if (name == ContractType.veBoostProxy) return "veBoostProxy";
         else if (name == ContractType.ProxyAdminGuardian)
-            cmd[4] = "proxyAdminGuardian";
-        else if (name == ContractType.AngleLabsMultisig)
-            cmd[4] = "angleLabsMultisig";
-        else if (name == ContractType.FlashLoan) cmd[4] = "flashloan";
+            return "ProxyAdminGuardian";
+        else if (name == ContractType.AngleLabsMultisig) return "AngleLabs";
+        else if (name == ContractType.FlashLoan) return "FlashAngle";
+        else if (name == ContractType.MultiBlockHarvester)
+            return "USD.MultiBlockHarvester";
+        else if (name == ContractType.GenericHarvester)
+            return "USD.GenericHarvester";
+        else if (name == ContractType.Harvester) return "USD.Harvester";
+        else if (name == ContractType.Rebalancer) return "USD.Rebalancer";
+        else if (name == ContractType.MulticallWithFailure)
+            return "MulticallWithFailure";
+        else if (name == ContractType.OracleNativeUSD) return "OracleNativeUSD";
+        else if (name == ContractType.Swapper) return "Swapper";
+        else if (name == ContractType.AngleHelpers) return "AngleHelpers";
         else revert("contract not supported");
-
-        VmSafe.FfiResult memory res = vm.tryFfi(cmd);
-        if (res.exitCode != 0) revert("Chain not supported");
-        return address(bytes20(res.stdout));
     }
 
     function _stringToUint(string memory s) internal pure returns (uint) {
diff --git a/src/Constants.sol b/src/Constants.sol
index 54320c2..f78062b 100644
--- a/src/Constants.sol
+++ b/src/Constants.sol
@@ -21,6 +21,7 @@ enum ContractType {
     CoreMerkl,
     DistributionCreator,
     Distributor,
+    Disputer,
     FeeDistributor,
     GaugeController,
     Governor,
@@ -42,29 +43,59 @@ enum ContractType {
     veBoost,
     veBoostProxy,
     ProxyAdminGuardian,
-    FlashLoan
+    FlashLoan,
+    MultiBlockHarvester,
+    GenericHarvester,
+    Harvester,
+    Rebalancer,
+    MulticallWithFailure,
+    OracleNativeUSD,
+    Swapper,
+    AngleHelpers
 }
 
-uint256 constant CHAIN_FORK = 0;
-uint256 constant CHAIN_ETHEREUM = 1;
-uint256 constant CHAIN_ARBITRUM = 42161;
-uint256 constant CHAIN_AVALANCHE = 43114;
-uint256 constant CHAIN_OPTIMISM = 10;
-uint256 constant CHAIN_POLYGON = 137;
-uint256 constant CHAIN_FANTOM = 250;
-uint256 constant CHAIN_GNOSIS = 100;
-uint256 constant CHAIN_BNB = 56;
-uint256 constant CHAIN_CELO = 42220;
-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_MODE = 34443;
-uint256 constant CHAIN_BLAST = 81457;
-uint256 constant CHAIN_XLAYER = 196;
+library Constants {
+    uint256 constant CHAIN_FORK = 0;
+    uint256 constant CHAIN_ETHEREUM = 1;
+    uint256 constant CHAIN_ARBITRUM = 42161;
+    uint256 constant CHAIN_AVALANCHE = 43114;
+    uint256 constant CHAIN_OPTIMISM = 10;
+    uint256 constant CHAIN_POLYGON = 137;
+    uint256 constant CHAIN_FANTOM = 250;
+    uint256 constant CHAIN_GNOSIS = 100;
+    uint256 constant CHAIN_BNB = 56;
+    uint256 constant CHAIN_CELO = 42220;
+    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_MODE = 34443;
+    uint256 constant CHAIN_BLAST = 81457;
+    uint256 constant CHAIN_XLAYER = 196;
+    uint256 constant CHAIN_THUNDERCORE = 108;
+    uint256 constant CHAIN_COREDAO = 1116;
+    uint256 constant CHAIN_TAIKO = 167000;
+    uint256 constant CHAIN_FUSE = 122;
+    uint256 constant CHAIN_IMMUTABLE = 13371;
+    uint256 constant CHAIN_SCROLL = 534352;
+    uint256 constant CHAIN_MANTA = 169;
+    uint256 constant CHAIN_SEI = 1329;
+    uint256 constant CHAIN_FRAXTAL = 252;
+    uint256 constant CHAIN_ASTAR = 592;
+    uint256 constant CHAIN_ASTARZKEVM = 3776;
+    uint256 constant CHAIN_ROOTSTOCK = 30;
+    uint256 constant CHAIN_MOONBEAM = 1284;
+    uint256 constant CHAIN_SKALE = 2046399126;
+    uint256 constant CHAIN_WORLDCHAIN = 480;
+    uint256 constant CHAIN_LISK = 1135;
+    uint256 constant CHAIN_ETHERLINK = 42793;
+    uint256 constant CHAIN_ARTHERA = 10242;
+    uint256 constant CHAIN_SWELL = 1923;
 
-uint256 constant BASE_18 = 1e18;
-uint256 constant BASE_9 = 1e9;
+    uint256 constant BASE_18 = 1e18;
+    uint256 constant BASE_9 = 1e9;
 
-address constant IMMUTABLE_CREATE2_FACTORY_ADDRESS = 0x0000000000FFe8B47B3e2130213B802212439497;
+    address constant IMMUTABLE_CREATE2_FACTORY_ADDRESS =
+        0x0000000000FFe8B47B3e2130213B802212439497;
+}
diff --git a/src/JsonReader.sol b/src/JsonReader.sol
new file mode 100644
index 0000000..5985e7d
--- /dev/null
+++ b/src/JsonReader.sol
@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.17;
+
+import {Script} from "forge-std/Script.sol";
+import {stdJson} from "forge-std/StdJson.sol";
+import {ContractType} from "./Constants.sol";
+
+contract JsonReader is Script {
+    using stdJson for string;
+
+    error FileNotFound(string path);
+    error ValueNotFound(string path, string key);
+    error ChainNotSupported(uint256 chainId);
+
+    // Mapping of chain IDs to their names
+    mapping(uint256 => string) internal chainNames;
+
+    /// @notice Gets the network-specific config path
+    /// @return The full path to the network config file
+    function getPath() public view returns (string memory) {
+        string memory root = vm.projectRoot();
+        return
+            string.concat(
+                root,
+                "/node_modules/@angleprotocol/sdk/dist/src/registry/registry.json"
+            );
+    }
+
+    /// @notice Reads an address value from the network's JSON file
+    /// @param chainId The chain ID
+    /// @param key The JSON key to read
+    /// @return The address value
+    function readAddress(
+        uint256 chainId,
+        string memory key
+    ) public view returns (address) {
+        string memory path = getPath();
+        return
+            readAddressFromPath(
+                path,
+                string.concat(vm.toString(chainId), ".", key)
+            );
+    }
+
+    /// @notice Reads a string value from the network's JSON file
+    /// @param chainId The chain ID
+    /// @param key The JSON key to read
+    /// @return The string value
+    function readString(
+        uint256 chainId,
+        string memory key
+    ) public view returns (string memory) {
+        string memory path = getPath();
+        return
+            readStringFromPath(
+                path,
+                string.concat(vm.toString(chainId), ".", key)
+            );
+    }
+
+    /// @notice Reads a uint256 value from the network's JSON file
+    /// @param chainId The chain ID
+    /// @param key The JSON key to read
+    /// @return The uint256 value
+    function readUint(
+        uint256 chainId,
+        string memory key
+    ) public view returns (uint256) {
+        string memory path = getPath();
+        return
+            readUintFromPath(
+                path,
+                string.concat(vm.toString(chainId), ".", key)
+            );
+    }
+
+    /// @notice Reads a string array from the network's JSON file
+    /// @param chainId The chain ID
+    /// @param key The JSON key to read
+    /// @return The string array
+    function readStringArray(
+        uint256 chainId,
+        string memory key
+    ) public view returns (string[] memory) {
+        string memory path = getPath();
+        return
+            readStringArrayFromPath(
+                path,
+                string.concat(vm.toString(chainId), ".", key)
+            );
+    }
+
+    // Direct path reading functions
+    function readAddressFromPath(
+        string memory path,
+        string memory key
+    ) public view returns (address) {
+        string memory json = readJsonFile(path);
+        bytes memory raw = json.parseRaw(string.concat(".", key));
+        if (raw.length == 0) revert ValueNotFound(path, key);
+        return bytesToAddress(raw);
+    }
+
+    function readStringFromPath(
+        string memory path,
+        string memory key
+    ) public view returns (string memory) {
+        string memory json = readJsonFile(path);
+        bytes memory raw = json.parseRaw(string.concat(".", key));
+        if (raw.length == 0) revert ValueNotFound(path, key);
+        return string(raw);
+    }
+
+    function readUintFromPath(
+        string memory path,
+        string memory key
+    ) public view returns (uint256) {
+        string memory json = readJsonFile(path);
+        bytes memory raw = json.parseRaw(string.concat(".", key));
+        if (raw.length == 0) revert ValueNotFound(path, key);
+        return abi.decode(raw, (uint256));
+    }
+
+    function readStringArrayFromPath(
+        string memory path,
+        string memory key
+    ) public view returns (string[] memory) {
+        string memory json = readJsonFile(path);
+        bytes memory raw = json.parseRaw(string.concat(".", key));
+        if (raw.length == 0) revert ValueNotFound(path, key);
+        return abi.decode(raw, (string[]));
+    }
+
+    /// @notice Reads a JSON file from the given path
+    /// @param path The path to the JSON file
+    /// @return The JSON content as a string
+    function readJsonFile(
+        string memory path
+    ) public view returns (string memory) {
+        try vm.readFile(path) returns (string memory json) {
+            return json;
+        } catch {
+            revert FileNotFound(path);
+        }
+    }
+
+    /// @notice Utility function to convert bytes to address
+    /// @param bys Bytes to convert
+    /// @return addr Resulting address
+    function bytesToAddress(
+        bytes memory bys
+    ) private pure returns (address addr) {
+        assembly {
+            addr := mload(add(bys, 32))
+        }
+    }
+}
diff --git a/src/RouterSwapper.sol b/src/RouterSwapper.sol
index b2c7f18..8cff40e 100644
--- a/src/RouterSwapper.sol
+++ b/src/RouterSwapper.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.0;
 
-import { SafeERC20, IERC20 } from "oz/token/ERC20/utils/SafeERC20.sol";
+import {SafeERC20, IERC20} from "oz/token/ERC20/utils/SafeERC20.sol";
 
 /// @title Swapper
 /// @author Angle Labs, Inc.
@@ -57,7 +57,10 @@ abstract contract RouterSwapper {
                                CONSTRUCTOR
     //////////////////////////////////////////////////////////////*/
 
-    constructor(address initialSwapRouter, address initialTokenTransferAddress) {
+    constructor(
+        address initialSwapRouter,
+        address initialTokenTransferAddress
+    ) {
         swapRouter = initialSwapRouter;
         tokenTransferAddress = initialTokenTransferAddress;
     }
@@ -70,7 +73,9 @@ abstract contract RouterSwapper {
      * @notice Set the router/aggregator address
      * @param newSwapRouter address of the new router/aggregator
      */
-    function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {
+    function setSwapRouter(
+        address newSwapRouter
+    ) public virtual noZeroAddress(newSwapRouter) {
         swapRouter = newSwapRouter;
 
         emit SwapRouterUpdated(newSwapRouter);
@@ -98,7 +103,11 @@ abstract contract RouterSwapper {
      * @param spender address of the router/aggregator
      * @param amount amount to approve
      */
-    function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {
+    function _approveTokenIfNeeded(
+        address token,
+        address spender,
+        uint256 amount
+    ) internal {
         uint256 allowance = IERC20(token).allowance(address(this), spender);
         if (allowance < amount) {
             IERC20(token).safeIncreaseAllowance(spender, amount - allowance);
@@ -128,7 +137,11 @@ abstract contract RouterSwapper {
      * @param callDatas array of bytes to call the router/aggregator
      * @param amounts array of amounts to swap
      */
-    function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {
+    function _swapCalldata(
+        address[] calldata tokens,
+        bytes[] calldata callDatas,
+        uint256[] calldata amounts
+    ) internal {
         uint256 length = tokens.length;
         for (uint256 i; i < length; ++i) {
             _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);
@@ -142,7 +155,11 @@ abstract contract RouterSwapper {
      * @param callDatas array of bytes to call the router/aggregator
      * @param amounts array of amounts to swap
      */
-    function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {
+    function _swap(
+        address[] memory tokens,
+        bytes[] memory callDatas,
+        uint256[] memory amounts
+    ) internal {
         uint256 length = tokens.length;
         for (uint256 i; i < length; ++i) {
             _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);
diff --git a/src/VanityAddress.sol b/src/VanityAddress.sol
index 96a08bd..f254919 100644
--- a/src/VanityAddress.sol
+++ b/src/VanityAddress.sol
@@ -2,12 +2,12 @@
 
 pragma solidity ^0.8.12;
 
-import "stringutils/strings.sol";
-import "forge-std/Script.sol";
-import { StdAssertions } from "forge-std/Test.sol";
-import { stdJson } from "forge-std/StdJson.sol";
-import { console } from "forge-std/console.sol";
-import "../src/Constants.sol";
+import {strings} from "stringutils/strings.sol";
+import {Script} from "forge-std/Script.sol";
+import {StdAssertions} from "forge-std/Test.sol";
+import {stdJson} from "forge-std/StdJson.sol";
+import {console} from "forge-std/console.sol";
+import {Constants} from "./Constants.sol";
 
 contract VanityAddress is Script, StdAssertions {
     using stdJson for string;
@@ -21,24 +21,32 @@ contract VanityAddress is Script, StdAssertions {
                 uint256( // convert to uint to truncate upper digits.
                     keccak256( // compute the CREATE2 hash using 4 inputs.
                         abi.encodePacked( // pack all inputs to the hash together.
-                            hex"ff", // start with 0xff to distinguish from RLP.
-                            IMMUTABLE_CREATE2_FACTORY_ADDRESS, // this contract will be the caller.
-                            salt, // pass in the supplied salt value.
-                            keccak256(abi.encodePacked(initCode)) // pass in the hash of initialization code.
-                        )
+                                hex"ff", // start with 0xff to distinguish from RLP.
+                                Constants.IMMUTABLE_CREATE2_FACTORY_ADDRESS, // this contract will be the caller.
+                                salt, // pass in the supplied salt value.
+                                keccak256(abi.encodePacked(initCode)) // pass in the hash of initialization code.
+                            )
                     )
                 )
             )
         );
     }
 
-    function minePrefix(bytes memory initCode, address deployer, uint24 prefix, uint256 initInt, uint256 iterations) internal pure returns (address computedAddress, uint256 i) {
+    function minePrefix(
+        bytes memory initCode,
+        address deployer,
+        uint24 prefix,
+        uint256 initInt,
+        uint256 iterations
+    ) internal pure returns (address computedAddress, uint256 i) {
         // Deploy diamond
         i = initInt;
         bool found = false;
         while (!found && i - initInt < iterations) {
             computedAddress = _findDeploymentAddress(
-                bytes32(abi.encodePacked(deployer, abi.encodePacked(uint96(i)))),
+                bytes32(
+                    abi.encodePacked(deployer, abi.encodePacked(uint96(i)))
+                ),
                 initCode
             );
             if (uint24(uint160(bytes20(computedAddress)) >> 136) == prefix) {
@@ -51,12 +59,20 @@ contract VanityAddress is Script, StdAssertions {
         return (computedAddress, i);
     }
 
-    function minePostfix(bytes memory initCode, address deployer, uint24 postfix, uint256 initInt, uint256 iterations) internal pure returns (address computedAddress, uint256 i) {
+    function minePostfix(
+        bytes memory initCode,
+        address deployer,
+        uint24 postfix,
+        uint256 initInt,
+        uint256 iterations
+    ) internal pure returns (address computedAddress, uint256 i) {
         // Deploy diamond
         bool found = false;
         while (!found && i - initInt < iterations) {
             computedAddress = _findDeploymentAddress(
-                bytes32(abi.encodePacked(deployer, abi.encodePacked(uint96(i)))),
+                bytes32(
+                    abi.encodePacked(deployer, abi.encodePacked(uint96(i)))
+                ),
                 initCode
             );
             if (uint24(uint160(bytes20(computedAddress))) == postfix) {
@@ -67,18 +83,29 @@ contract VanityAddress is Script, StdAssertions {
         }
 
         return (computedAddress, i);
-
     }
 
-    function mine(bytes memory initCode, address deployer, uint24 prefix, uint24 postfix, uint256 initInt, uint256 iterations) internal pure returns (address computedAddress, uint256 i) {
+    function mine(
+        bytes memory initCode,
+        address deployer,
+        uint24 prefix,
+        uint24 postfix,
+        uint256 initInt,
+        uint256 iterations
+    ) internal pure returns (address computedAddress, uint256 i) {
         // Deploy diamond
         bool found = false;
         while (!found && i - initInt < iterations) {
             computedAddress = _findDeploymentAddress(
-                bytes32(abi.encodePacked(deployer, abi.encodePacked(uint96(i)))),
+                bytes32(
+                    abi.encodePacked(deployer, abi.encodePacked(uint96(i)))
+                ),
                 initCode
             );
-            if (uint24(uint160(bytes20(computedAddress))) == postfix && uint24(uint160(bytes20(computedAddress)) >> 136) == prefix) {
+            if (
+                uint24(uint160(bytes20(computedAddress))) == postfix &&
+                uint24(uint160(bytes20(computedAddress)) >> 136) == prefix
+            ) {
                 found = true;
                 break;
             }
diff --git a/test/CommonUtils.t.sol b/test/CommonUtils.t.sol
new file mode 100644
index 0000000..9c0fe55
--- /dev/null
+++ b/test/CommonUtils.t.sol
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+import {Test} from "forge-std/Test.sol";
+import {CommonUtils} from "../src/CommonUtils.sol";
+import {ContractType, Constants} from "../src/Constants.sol";
+import {console} from "forge-std/console.sol";
+contract CommonUtilsTest is Test, CommonUtils {
+    function setUp() public {
+        // Initialize any required setup
+        setUpForks();
+    }
+
+    function test_ChainToContract() public {
+        // Test AgEUR on Ethereum
+        address agEurEth = _chainToContract(
+            Constants.CHAIN_ETHEREUM,
+            ContractType.AgEUR
+        );
+        assertNotEq(agEurEth, address(0), "AgEUR not found on Ethereum");
+
+        // Test AgUSD on Arbitrum
+        address agUsdArb = _chainToContract(
+            Constants.CHAIN_ARBITRUM,
+            ContractType.AgUSD
+        );
+        assertNotEq(agUsdArb, address(0), "AgUSD not found on Arbitrum");
+
+        // Test ANGLE token on Ethereum
+        address angleEth = _chainToContract(
+            Constants.CHAIN_ETHEREUM,
+            ContractType.Angle
+        );
+        assertNotEq(angleEth, address(0), "ANGLE not found on Ethereum");
+    }
+
+    function test_ChainToContractRevert() public {
+        // Test with invalid contract type should revert
+        vm.expectRevert();
+        _chainToContract(Constants.CHAIN_AURORA, ContractType.Disputer); // Disputer not deployed (so far) on Aurora
+    }
+
+    function test_getChainIds() public {
+        uint256[] memory chains = _getChainIds();
+        assertEq(chains.length, 40, "Expected 40 chains");
+    }
+
+    function test_GetChainIdsWithDeployedContract() public {
+        uint256[] memory chains = _getChainIdsWithDeployedContract(
+            ContractType.DistributionCreator
+        );
+        assertEq(chains.length, 38, "Expected 38 chains");
+    }
+
+    function test_getChainIdsWithDeployedContract_MultiBlockHarvester() public {
+        uint256[] memory chains = _getChainIdsWithDeployedContract(
+            ContractType.MultiBlockHarvester
+        );
+        assertEq(chains.length, 1, "Expected 1 chains");
+    }
+
+    function test_getAllContracts() public {
+        address[] memory contracts = _getAllContracts(Constants.CHAIN_ETHEREUM);
+        address contractTest = contracts[0];
+        assertEq(contractTest, 0x16CA2999e5f5e43aEc2e6c18896655b9B05a1560);
+    }
+
+    function test_getConnectedChains() public {
+        (
+            uint256[] memory chainIds,
+            address[] memory contracts
+        ) = _getConnectedChains("ANGLE");
+
+        console.log("Number of connected chains:", chainIds.length);
+        for (uint i = 0; i < chainIds.length; i++) {
+            console.log("Chain ID %d:", chainIds[i]);
+            console.log("Contract:", contracts[i]);
+        }
+    }
+}
diff --git a/utils/contractAddress.js b/utils/contractAddress.js
deleted file mode 100644
index 9637baa..0000000
--- a/utils/contractAddress.js
+++ /dev/null
@@ -1,63 +0,0 @@
-const { registry } = require('@angleprotocol/sdk');
-const { ethers } = require('ethers');
-
-// Ensure an argument has been provided
-if (process.argv.length < 4) {
-  console.error('Please provide a chain input as an argument.');
-  process.exit(1);
-}
-
-// Get the argument from the command line input
-// process.argv[0] is the node command
-// process.argv[1] is the path to the runner.js file
-// process.argv[2] is the first argument provided by the user
-const chainInput = process.argv[2];
-const contracTtype = String(process.argv[3]);
-
-// Try to parse the input as a number if possible
-if(isNaN(Number(chainInput))) process.exit(1);
-const parsedInput = Number(chainInput);
-
-let contract
-
-if(contracTtype == "agEUR") contract = registry(parsedInput)?.EUR?.AgToken;
-else if(contracTtype == "agUSD") contract = registry(parsedInput)?.USD?.AgToken;
-else if(contracTtype == "agEURLz") contract = registry(parsedInput)?.EUR?.bridges.LayerZero;
-else if(contracTtype == "agUSDLz") contract = registry(parsedInput)?.USD?.bridges.LayerZero;
-else if(contracTtype == "angle") contract = registry(parsedInput)?.ANGLE;
-else if(contracTtype == "angleLz") contract = registry(parsedInput)?.bridges.LayerZero;
-else if(contracTtype == "angleDistributor") contract = registry(parsedInput)?.AngleDistributor;
-else if(contracTtype == "angleMiddleman") contract = registry(parsedInput)?.Middleman;
-else if(contracTtype == "angleRouter") contract = registry(parsedInput)?.AngleRouterV2;
-else if(contracTtype == "coreBorrow") contract = registry(parsedInput)?.CoreBorrow;
-else if(contracTtype == "coreMerkl") contract = registry(parsedInput)?.Merkl?.CoreMerkl;
-else if(contracTtype == "distributionCreator") contract = registry(parsedInput)?.Merkl?.DistributionCreator;
-else if(contracTtype == "distributor") contract = registry(parsedInput)?.Merkl?.Distributor;
-else if(contracTtype == "feeDistributor") contract = registry(parsedInput)?.FeeDistributor_sanUSDC_EUR;
-else if(contracTtype == "gaugeController") contract = registry(parsedInput)?.GaugeController;
-else if(contracTtype == "governor") contract =  registry(parsedInput)?.AngleGovernor;
-else if(contracTtype == "governorMultisig") contract = registry(parsedInput)?.Governor;
-else if(contracTtype == "guardianMultisig") contract =  registry(parsedInput)?.Guardian;
-else if(contracTtype == "merklMiddleman") contract = registry(parsedInput)?.MerklGaugeMiddleman;
-else if(contracTtype == "proposalReceiver")  contract = registry(parsedInput)?.ProposalReceiver;
-else if(contracTtype == "proposalSender") contract = registry(parsedInput)?.ProposalSender;
-else if(contracTtype == "proxyAdmin") contract = registry(parsedInput)?.ProxyAdmin;
-else if(contracTtype == "smartWalletWhitelist") contract = registry(parsedInput)?.SmartWalletWhitelist;
-else if(contracTtype == "stEUR") contract = registry(parsedInput)?.EUR?.Savings;
-else if(contracTtype == "stUSD") contract = registry(parsedInput)?.USD?.Savings;
-else if(contracTtype == "timelock") contract = registry(parsedInput)?.Timelock;
-else if(contracTtype == "transmuterAgEUR") contract = registry(parsedInput)?.EUR?.Transmuter;
-else if(contracTtype == "transmuterAgUSD") contract = registry(parsedInput)?.USD?.Transmuter;
-else if(contracTtype == "treasuryAgEUR") contract = registry(parsedInput)?.EUR?.Treasury;
-else if(contracTtype == "treasuryAgUSD") contract = registry(parsedInput)?.USD?.Treasury;
-else if(contracTtype == "veANGLE") contract = registry(parsedInput)?.veANGLE;
-else if(contracTtype == "veBoost") contract = registry(parsedInput)?.veBoost;
-else if(contracTtype == "veBoostProxy") contract = registry(parsedInput)?.veBoostProxy;
-else if(contracTtype == "proxyAdminGuardian") contract = registry(parsedInput)?.ProxyAdminGuardian;
-else if(contracTtype == "angleLabsMultisig") contract = registry(parsedInput)?.AngleLabs;
-else if (contracTtype == "flashloan") contract = registry(parsedInput)?.FlashAngle
-
-if(!contract) process.exit(1);
-// Call the function with the input
-const result = ethers.utils.getAddress(contract)?.toString()?.slice(2);
-console.log(result);
\ No newline at end of file
diff --git a/utils/getAllContracts.js b/utils/getAllContracts.js
deleted file mode 100644
index 1673020..0000000
--- a/utils/getAllContracts.js
+++ /dev/null
@@ -1,41 +0,0 @@
-const { registry } = require('@angleprotocol/sdk');
-const { ethers } = require('ethers');
-
-// Ensure an argument has been provided
-if (process.argv.length < 3) {
-  console.error('Please provide a chain input as an argument.');
-  process.exit(1);
-}
-
-// Get the argument from the command line input
-// process.argv[0] is the node command
-// process.argv[1] is the path to the runner.js file
-// process.argv[2] is the first argument provided by the user
-const chainInput = process.argv[2];
-
-// Try to parse the input as a number if possible
-if(isNaN(Number(chainInput))) process.exit(1);
-const parsedInput = Number(chainInput);
-
-// Function to get all addresses from the registry
-function getAllAddresses(registry) {
-  let addresses = [];
-
-  for (let key in registry) {
-    if (typeof registry[key] === 'object' && registry[key] !== null) {
-      // If the value is a nested object, recursively get addresses
-      addresses = addresses.concat(getAllAddresses(registry[key]));
-    } else if (ethers.utils.isAddress(registry[key])) {
-      // If the value is not an object, assume it's an address and add to the list
-      addresses.push(ethers.utils.getAddress(registry[key])?.toString());
-    }
-  }
-
-  return addresses;
-}
-
-// Call the function with the registry
-let allAddresses = getAllAddresses(registry(parsedInput));
-allAddresses = [...new Set(allAddresses)];
-const encodedAddresses = ethers.utils.defaultAbiCoder.encode(['address[]'], [allAddresses]);
-console.log(encodedAddresses);
\ No newline at end of file
diff --git a/utils/getConnectedChains.js b/utils/getConnectedChains.js
deleted file mode 100644
index e9af07a..0000000
--- a/utils/getConnectedChains.js
+++ /dev/null
@@ -1,37 +0,0 @@
-const { registry, ChainId } = require('@angleprotocol/sdk');
-
-if (process.argv.length < 3) {
-    console.log('Usage: node getConnectedChains.js <chainId>');
-    process.exit(1);
-}
-
-const contract = process.argv[2];
-
-// Try to parse the input as a number if possible
-let contracts = [];
-let chains = [];
-
-for (const chain in ChainId) {
-    switch (contract) {
-        case 'EUR':
-            if (registry(chain)?.EUR?.bridges?.LayerZero) {
-                contracts.push(registry(chain)?.EUR?.bridges?.LayerZero);
-                chains.push(chain);
-            }
-            break;
-        case 'USD':
-            if (registry(chain)?.USD?.bridges?.LayerZero) {
-                contracts.push(registry(chain).USD.bridges?.LayerZero);
-                chains.push(chain);
-            }
-            break;
-        case 'ANGLE':
-            if (registry(chain)?.bridges?.LayerZero) {
-                contracts.push(registry(chain).bridges.LayerZero);
-                chains.push(chain);
-            }
-            break;
-    }
-}
-
-console.log(JSON.stringify({contracts, chains}));
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 2cc5a5c..2ba3a0a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,14 +2,24 @@
 # yarn lockfile v1
 
 
-"@angleprotocol/sdk@^0.37.1":
-  version "0.37.1"
-  resolved "https://npm.pkg.github.com/download/@angleprotocol/sdk/0.37.1/3c2510ecd61d08649d758be4e4e27517bffa3f61#3c2510ecd61d08649d758be4e4e27517bffa3f61"
-  integrity sha512-KkKa14U2AafSiVbigcJrWexH3uTJ2hmcRh8Bp7SPoYf8CJSOaXzT+HbX0KC0LWDWjZcts+0YOhmjFmUFmy/Rtg==
+"@adraffy/ens-normalize@^1.10.1":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@adraffy/ens-normalize/-/ens-normalize-1.11.0.tgz#42cc67c5baa407ac25059fcd7d405cc5ecdb0c33"
+  integrity sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==
+
+"@angleprotocol/sdk@^2.34.7":
+  version "2.34.7"
+  resolved "https://npm.pkg.github.com/download/@angleprotocol/sdk/2.34.7/453c7b34d2f939013dfe0b6d4d886fcafa1ba9d7#453c7b34d2f939013dfe0b6d4d886fcafa1ba9d7"
+  integrity sha512-LiwZ/mDNNFuoDmAsWLc1DDwA7mYglHfyHH0NPuCtwDiT1XKrlSpBqnAKqffS6xsEgqtUeeH5hs8AvFu5+k2d2Q==
   dependencies:
     "@apollo/client" "^3.7.17"
     "@typechain/ethers-v5" "^10.0.0"
-    "@types/lodash" "^4.14.180"
+    "@types/lodash" "^4.17.13"
+    axios "^1.7.7"
+    bun-types "^1.1.27"
+    class-transformer "^0.5.1"
+    class-validator "^0.14.1"
+    cross-fetch "^4.0.0"
     ethers "^5.6.4"
     graphql "^15.7.1"
     graphql-request "^3.6.1"
@@ -17,8 +27,10 @@
     keccak256 "^1.0.6"
     lodash "^4.17.21"
     merkletreejs "^0.3.10"
+    reflect-metadata "^0.2.2"
     tiny-invariant "^1.1.0"
     typechain "^8.3.2"
+    viem "^2.21.54"
 
 "@apollo/client@^3.7.17":
   version "3.9.5"
@@ -408,16 +420,38 @@
   dependencies:
     "@noble/hashes" "1.3.3"
 
+"@noble/curves@1.7.0", "@noble/curves@^1.4.0", "@noble/curves@^1.6.0", "@noble/curves@~1.7.0":
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-1.7.0.tgz#0512360622439256df892f21d25b388f52505e45"
+  integrity sha512-UTMhXK9SeDhFJVrHeUJ5uZlI6ajXg10O6Ddocf9S6GjbSBVZsJo88HzKwXznNfGpMTRDyJkqMjNDPYgf0qFWnw==
+  dependencies:
+    "@noble/hashes" "1.6.0"
+
 "@noble/hashes@1.3.3", "@noble/hashes@~1.3.2":
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.3.3.tgz#39908da56a4adc270147bb07968bf3b16cfe1699"
   integrity sha512-V7/fPHgl+jsVPXqqeOzT8egNj2iBIVt+ECeMMG8TdcnTikP3oaBtUVqpT/gYCR68aEBJSF+XbYUxStjbFMqIIA==
 
+"@noble/hashes@1.6.0":
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.6.0.tgz#d4bfb516ad6e7b5111c216a5cc7075f4cf19e6c5"
+  integrity sha512-YUULf0Uk4/mAA89w+k3+yUYh6NrEvxZa5T6SY3wlMvE2chHkxFUUIDI8/XW1QSC357iA5pSnqt7XEhvFOqmDyQ==
+
+"@noble/hashes@1.6.1", "@noble/hashes@^1.4.0", "@noble/hashes@^1.5.0", "@noble/hashes@~1.6.0":
+  version "1.6.1"
+  resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.6.1.tgz#df6e5943edcea504bac61395926d6fd67869a0d5"
+  integrity sha512-pq5D8h10hHBjyqX+cfBm0i8JUXJ0UhczFc4r74zbuT9XgewFo2E3J1cOaGtdZynILNmQ685YWGzGE1Zv6io50w==
+
 "@scure/base@~1.1.4":
   version "1.1.5"
   resolved "https://registry.yarnpkg.com/@scure/base/-/base-1.1.5.tgz#1d85d17269fe97694b9c592552dd9e5e33552157"
   integrity sha512-Brj9FiG2W1MRQSTB212YVPRrcbjkv48FoZi/u4l/zds/ieRrqsh7aUf6CLwkAq61oKXr/ZlTzlY66gLIj3TFTQ==
 
+"@scure/base@~1.2.1":
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/@scure/base/-/base-1.2.1.tgz#dd0b2a533063ca612c17aa9ad26424a2ff5aa865"
+  integrity sha512-DGmGtC8Tt63J5GfHgfl5CuAXh96VF/LD8K9Hr/Gv0J2lAoRGlPOMpqMpMbCTOoOJMZCk2Xt+DskdDyn6dEFdzQ==
+
 "@scure/bip32@1.3.3":
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/@scure/bip32/-/bip32-1.3.3.tgz#a9624991dc8767087c57999a5d79488f48eae6c8"
@@ -427,6 +461,15 @@
     "@noble/hashes" "~1.3.2"
     "@scure/base" "~1.1.4"
 
+"@scure/bip32@1.6.0", "@scure/bip32@^1.5.0":
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/@scure/bip32/-/bip32-1.6.0.tgz#6dbc6b4af7c9101b351f41231a879d8da47e0891"
+  integrity sha512-82q1QfklrUUdXJzjuRU7iG7D7XiFx5PHYVS0+oeNKhyDLT7WPqs6pBcM2W5ZdwOwKCwoE1Vy1se+DHjcXwCYnA==
+  dependencies:
+    "@noble/curves" "~1.7.0"
+    "@noble/hashes" "~1.6.0"
+    "@scure/base" "~1.2.1"
+
 "@scure/bip39@1.2.2":
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/@scure/bip39/-/bip39-1.2.2.tgz#f3426813f4ced11a47489cbcf7294aa963966527"
@@ -435,6 +478,14 @@
     "@noble/hashes" "~1.3.2"
     "@scure/base" "~1.1.4"
 
+"@scure/bip39@1.5.0", "@scure/bip39@^1.4.0":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@scure/bip39/-/bip39-1.5.0.tgz#c8f9533dbd787641b047984356531d84485f19be"
+  integrity sha512-Dop+ASYhnrwm9+HA/HwXg7j2ZqM6yk2fyLWb5znexjctFY3+E+eU8cIWI0Pql0Qx4hPZCijlGq4OL71g+Uz30A==
+  dependencies:
+    "@noble/hashes" "~1.6.0"
+    "@scure/base" "~1.2.1"
+
 "@typechain/ethers-v5@^10.0.0":
   version "10.2.1"
   resolved "https://registry.yarnpkg.com/@typechain/ethers-v5/-/ethers-v5-10.2.1.tgz#50241e6957683281ecfa03fb5a6724d8a3ce2391"
@@ -443,16 +494,42 @@
     lodash "^4.17.15"
     ts-essentials "^7.0.1"
 
-"@types/lodash@^4.14.180":
-  version "4.14.202"
-  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.202.tgz#f09dbd2fb082d507178b2f2a5c7e74bd72ff98f8"
-  integrity sha512-OvlIYQK9tNneDlS0VN54LLd5uiPCBOp7gS5Z0f1mjoJYBrtStzgmJBxONW3U6OZqdtNzZPmn9BS/7WI7BFFcFQ==
+"@types/lodash@^4.17.13":
+  version "4.17.13"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.17.13.tgz#786e2d67cfd95e32862143abe7463a7f90c300eb"
+  integrity sha512-lfx+dftrEZcdBPczf9d0Qv0x+j/rfNCMuC6OcfXmO8gkfeNAY88PgKUbvG56whcN23gc27yenwF6oJZXGFpYxg==
+
+"@types/node@*":
+  version "22.9.0"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-22.9.0.tgz#b7f16e5c3384788542c72dc3d561a7ceae2c0365"
+  integrity sha512-vuyHg81vvWA1Z1ELfvLko2c8f34gyA0zaic0+Rllc5lbCnbSyuvb2Oxpm6TAUAC/2xZN3QGqxBNggD1nNR2AfQ==
+  dependencies:
+    undici-types "~6.19.8"
+
+"@types/node@~20.12.8":
+  version "20.12.14"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.12.14.tgz#0c5cf7ef26aedfd64b0539bba9380ed1f57dcc77"
+  integrity sha512-scnD59RpYD91xngrQQLGkE+6UrHUPzeKZWhhjBSa3HSkwjbQc38+q3RoIVEwxQGRw3M+j5hpNAM+lgV3cVormg==
+  dependencies:
+    undici-types "~5.26.4"
 
 "@types/prettier@^2.1.1":
   version "2.7.3"
   resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.7.3.tgz#3e51a17e291d01d17d3fc61422015a933af7a08f"
   integrity sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==
 
+"@types/validator@^13.11.8":
+  version "13.12.2"
+  resolved "https://registry.yarnpkg.com/@types/validator/-/validator-13.12.2.tgz#760329e756e18a4aab82fc502b51ebdfebbe49f5"
+  integrity sha512-6SlHBzUW8Jhf3liqrGGXyTJSIFe4nqlJ5A5KaMZ2l/vbM3Wh3KSybots/wfWVzNLK4D1NZluDlSQIbIEPx6oyA==
+
+"@types/ws@~8.5.10":
+  version "8.5.13"
+  resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.13.tgz#6414c280875e2691d0d1e080b05addbf5cb91e20"
+  integrity sha512-osM/gWBTPKgHV8XkTunnegTRIsvF6owmf5w+JtAfOw472dptdm0dlGv4xCt6GwQRcC2XVOvvRE/0bAoQcL2QkA==
+  dependencies:
+    "@types/node" "*"
+
 "@wry/caches@^1.0.0":
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/@wry/caches/-/caches-1.0.1.tgz#8641fd3b6e09230b86ce8b93558d44cf1ece7e52"
@@ -488,6 +565,11 @@
   dependencies:
     tslib "^2.3.0"
 
+abitype@1.0.7, abitype@^1.0.6:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/abitype/-/abitype-1.0.7.tgz#876a0005d211e1c9132825d45bcee7b46416b284"
+  integrity sha512-ZfYYSktDQUwc2eduYu8C4wOs+RDPmnRYMh7zNfzeMtGGgb0U+6tLGjixUic6mXf5xKKCcgT5Qp6cv39tOARVFw==
+
 aes-js@3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/aes-js/-/aes-js-3.0.0.tgz#e21df10ad6c2053295bcbb8dab40b09dbea87e4d"
@@ -522,6 +604,15 @@ asynckit@^0.4.0:
   resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
   integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
 
+axios@^1.7.7:
+  version "1.7.9"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.9.tgz#d7d071380c132a24accda1b2cfc1535b79ec650a"
+  integrity sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==
+  dependencies:
+    follow-redirects "^1.15.6"
+    form-data "^4.0.0"
+    proxy-from-env "^1.1.0"
+
 balanced-match@^1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
@@ -583,6 +674,14 @@ buffer@^6.0.3:
     base64-js "^1.3.1"
     ieee754 "^1.2.1"
 
+bun-types@^1.1.27:
+  version "1.1.34"
+  resolved "https://registry.yarnpkg.com/bun-types/-/bun-types-1.1.34.tgz#cf0e1dc5aa8875573a3acb09bead0f23bab5aca2"
+  integrity sha512-br5QygTEL/TwB4uQOb96Ky22j4Gq2WxWH/8Oqv20fk5HagwKXo/akB+LiYgSfzexCt6kkcUaVm+bKiPl71xPvw==
+  dependencies:
+    "@types/node" "~20.12.8"
+    "@types/ws" "~8.5.10"
+
 chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
@@ -600,6 +699,20 @@ chalk@^4.1.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
+class-transformer@^0.5.1:
+  version "0.5.1"
+  resolved "https://registry.yarnpkg.com/class-transformer/-/class-transformer-0.5.1.tgz#24147d5dffd2a6cea930a3250a677addf96ab336"
+  integrity sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw==
+
+class-validator@^0.14.1:
+  version "0.14.1"
+  resolved "https://registry.yarnpkg.com/class-validator/-/class-validator-0.14.1.tgz#ff2411ed8134e9d76acfeb14872884448be98110"
+  integrity sha512-2VEG9JICxIqTpoK1eMzZqaV+u/EiwEJkMGzTrZf6sU/fwsnOITVgYJ8yojSy6CaXtO9V0Cc6ZQZ8h8m4UBuLwQ==
+  dependencies:
+    "@types/validator" "^13.11.8"
+    libphonenumber-js "^1.10.53"
+    validator "^13.9.0"
+
 color-convert@^1.9.0:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
@@ -663,6 +776,13 @@ cross-fetch@^3.0.6:
   dependencies:
     node-fetch "^2.6.12"
 
+cross-fetch@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-4.0.0.tgz#f037aef1580bb3a1a35164ea2a848ba81b445983"
+  integrity sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==
+  dependencies:
+    node-fetch "^2.6.12"
+
 crypto-js@^4.2.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/crypto-js/-/crypto-js-4.2.0.tgz#4d931639ecdfd12ff80e8186dba6af2c2e856631"
@@ -764,6 +884,11 @@ ethjs-unit@0.1.6:
     bn.js "4.11.6"
     number-to-bn "1.7.0"
 
+eventemitter3@5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-5.0.1.tgz#53f5ffd0a492ac800721bb42c66b841de96423c4"
+  integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==
+
 extract-files@^9.0.0:
   version "9.0.0"
   resolved "https://registry.yarnpkg.com/extract-files/-/extract-files-9.0.0.tgz#8a7744f2437f81f5ed3250ed9f1550de902fe54a"
@@ -776,6 +901,11 @@ find-replace@^3.0.0:
   dependencies:
     array-back "^3.0.1"
 
+follow-redirects@^1.15.6:
+  version "1.15.9"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.9.tgz#a604fa10e443bf98ca94228d9eebcc2e8a2c8ee1"
+  integrity sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==
+
 form-data@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f"
@@ -785,6 +915,15 @@ form-data@^3.0.0:
     combined-stream "^1.0.8"
     mime-types "^2.1.12"
 
+form-data@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.1.tgz#ba1076daaaa5bfd7e99c1a6cb02aa0a5cff90d48"
+  integrity sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==
+  dependencies:
+    asynckit "^0.4.0"
+    combined-stream "^1.0.8"
+    mime-types "^2.1.12"
+
 fs-extra@^7.0.0:
   version "7.0.1"
   resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-7.0.1.tgz#4f189c44aa123b895f722804f55ea23eadc348e9"
@@ -894,6 +1033,11 @@ is-hex-prefixed@1.0.0:
   resolved "https://registry.yarnpkg.com/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz#7d8d37e6ad77e5d127148913c573e082d777f554"
   integrity sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==
 
+isows@1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/isows/-/isows-1.0.6.tgz#0da29d706fa51551c663c627ace42769850f86e7"
+  integrity sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw==
+
 js-sha3@0.8.0, js-sha3@^0.8.0:
   version "0.8.0"
   resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840"
@@ -934,6 +1078,11 @@ keccak@^3.0.2:
     node-gyp-build "^4.2.0"
     readable-stream "^3.6.0"
 
+libphonenumber-js@^1.10.53:
+  version "1.11.14"
+  resolved "https://registry.yarnpkg.com/libphonenumber-js/-/libphonenumber-js-1.11.14.tgz#d753524fd30e6433834a1464baf7efed4a06b593"
+  integrity sha512-sexvAfwcW1Lqws4zFp8heAtAEXbEDnvkYCEGzvOoMgZR7JhXo/IkE9MkkGACgBed5fWqh3ShBGnJBdDnU9N8EQ==
+
 lodash.camelcase@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
@@ -1053,6 +1202,19 @@ optimism@^0.18.0:
     "@wry/trie" "^0.4.3"
     tslib "^2.3.0"
 
+ox@0.1.2:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/ox/-/ox-0.1.2.tgz#0f791be2ccabeaf4928e6d423498fe1c8094e560"
+  integrity sha512-ak/8K0Rtphg9vnRJlbOdaX9R7cmxD2MiSthjWGaQdMk3D7hrAlDoM+6Lxn7hN52Za3vrXfZ7enfke/5WjolDww==
+  dependencies:
+    "@adraffy/ens-normalize" "^1.10.1"
+    "@noble/curves" "^1.6.0"
+    "@noble/hashes" "^1.5.0"
+    "@scure/bip32" "^1.5.0"
+    "@scure/bip39" "^1.4.0"
+    abitype "^1.0.6"
+    eventemitter3 "5.0.1"
+
 path-is-absolute@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
@@ -1072,6 +1234,11 @@ prop-types@^15.7.2:
     object-assign "^4.1.1"
     react-is "^16.13.1"
 
+proxy-from-env@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
+  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
+
 randombytes@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
@@ -1098,6 +1265,11 @@ reduce-flatten@^2.0.0:
   resolved "https://registry.yarnpkg.com/reduce-flatten/-/reduce-flatten-2.0.0.tgz#734fd84e65f375d7ca4465c69798c25c9d10ae27"
   integrity sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==
 
+reflect-metadata@^0.2.2:
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.2.tgz#400c845b6cba87a21f2c65c4aeb158f4fa4d9c5b"
+  integrity sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==
+
 rehackt@0.0.5:
   version "0.0.5"
   resolved "https://registry.yarnpkg.com/rehackt/-/rehackt-0.0.5.tgz#184c82ea369d5b0b989ede0593ebea8b2bcfb1d6"
@@ -1234,6 +1406,16 @@ typical@^5.2.0:
   resolved "https://registry.yarnpkg.com/typical/-/typical-5.2.0.tgz#4daaac4f2b5315460804f0acf6cb69c52bb93066"
   integrity sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==
 
+undici-types@~5.26.4:
+  version "5.26.5"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
+  integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
+
+undici-types@~6.19.8:
+  version "6.19.8"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.19.8.tgz#35111c9d1437ab83a7cdc0abae2f26d88eda0a02"
+  integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==
+
 universalify@^0.1.0:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
@@ -1249,6 +1431,26 @@ util-deprecate@^1.0.1:
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
+validator@^13.9.0:
+  version "13.12.0"
+  resolved "https://registry.yarnpkg.com/validator/-/validator-13.12.0.tgz#7d78e76ba85504da3fee4fd1922b385914d4b35f"
+  integrity sha512-c1Q0mCiPlgdTVVVIJIrBuxNicYE+t/7oKeI9MWLj3fh/uq2Pxh/3eeWbVZ4OcGW1TUf53At0njHw5SMdA3tmMg==
+
+viem@^2.21.54:
+  version "2.21.54"
+  resolved "https://registry.yarnpkg.com/viem/-/viem-2.21.54.tgz#76d6f86ab8809078f1ac140ac1a2beadbc86b9f6"
+  integrity sha512-G9mmtbua3UtnVY9BqAtWdNp+3AO+oWhD0B9KaEsZb6gcrOWgmA4rz02yqEMg+qW9m6KgKGie7q3zcHqJIw6AqA==
+  dependencies:
+    "@noble/curves" "1.7.0"
+    "@noble/hashes" "1.6.1"
+    "@scure/bip32" "1.6.0"
+    "@scure/bip39" "1.5.0"
+    abitype "1.0.7"
+    isows "1.0.6"
+    ox "0.1.2"
+    webauthn-p256 "0.0.10"
+    ws "8.18.0"
+
 web3-utils@^1.3.4:
   version "1.10.3"
   resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.10.3.tgz#f1db99c82549c7d9f8348f04ffe4e0188b449714"
@@ -1263,6 +1465,14 @@ web3-utils@^1.3.4:
     randombytes "^2.1.0"
     utf8 "3.0.0"
 
+webauthn-p256@0.0.10:
+  version "0.0.10"
+  resolved "https://registry.yarnpkg.com/webauthn-p256/-/webauthn-p256-0.0.10.tgz#877e75abe8348d3e14485932968edf3325fd2fdd"
+  integrity sha512-EeYD+gmIT80YkSIDb2iWq0lq2zbHo1CxHlQTeJ+KkCILWpVy3zASH3ByD4bopzfk0uCwXxLqKGLqp2W4O28VFA==
+  dependencies:
+    "@noble/curves" "^1.4.0"
+    "@noble/hashes" "^1.4.0"
+
 webidl-conversions@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
@@ -1294,6 +1504,11 @@ ws@7.4.6:
   resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c"
   integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==
 
+ws@8.18.0:
+  version "8.18.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.18.0.tgz#0d7505a6eafe2b0e712d232b42279f53bc289bbc"
+  integrity sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==
+
 zen-observable-ts@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/zen-observable-ts/-/zen-observable-ts-1.2.5.tgz#6c6d9ea3d3a842812c6e9519209365a122ba8b58"