Add multisend differential test against deployments

Author: aviggiano

package-lock.json

@@ -1,6 +1,7 @@
 {
   "name": "safe-utils",
   "devDependencies": {
-    "@safe-global/api-kit": "4.1.0"
+    "@safe-global/api-kit": "4.1.0",
+    "@safe-global/safe-deployments": "1.37.53"
   }
 }

package.json

@@ -30,6 +30,31 @@ contract SafeDifferentialTest is Test {
         }
     }
 
+    function test_Safe_multiSendConfig_matchesSafeDeployments() public {
+        (uint256[] memory chainIds, uint256[] memory counts, address[] memory addresses) =
+            _readSafeDeploymentsMultiSendConfig();
+
+        assertEq(chainIds.length, counts.length);
+
+        uint256 cursor;
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            address resolved = address(safe.getMultiSendCallOnly(chainIds[i]));
+            bool found;
+
+            for (uint256 j = 0; j < counts[i]; j++) {
+                if (resolved == addresses[cursor + j]) {
+                    found = true;
+                    break;
+                }
+            }
+
+            assertTrue(found, string.concat("unexpected multisend address for chain ", vm.toString(chainIds[i])));
+            cursor += counts[i];
+        }
+
+        assertEq(cursor, addresses.length);
+    }
+
     function _readTypeScriptSdkConfig() private returns (uint256[] memory chainIds, string[] memory urls) {
         string[] memory inputs = new string[](2);
         inputs[0] = "node";
@@ -39,4 +64,18 @@ contract SafeDifferentialTest is Test {
         chainIds = json.readUintArray(".chainIds");
         urls = json.readStringArray(".urls");
     }
+
+    function _readSafeDeploymentsMultiSendConfig()
+        private
+        returns (uint256[] memory chainIds, uint256[] memory counts, address[] memory addresses)
+    {
+        string[] memory inputs = new string[](2);
+        inputs[0] = "node";
+        inputs[1] = "test/ffi/safe-multisend-config.cjs";
+
+        string memory json = string(vm.ffi(inputs));
+        chainIds = json.readUintArray(".chainIds");
+        counts = json.readUintArray(".counts");
+        addresses = json.readAddressArray(".addresses");
+    }
 }

test/SafeDifferential.t.sol

@@ -0,0 +1,87 @@
+const fs = require("fs");
+const path = require("path");
+const vm = require("vm");
+
+const MIN_EXPECTED_NETWORKS = 39;
+const SUPPORTED_THIRD_PARTY_CHAIN_IDS = [98866];
+const MULTI_SEND_VERSIONS = ["1.5.0", "1.4.1", "1.3.0"];
+
+const apiKitBundlePath = require.resolve("@safe-global/api-kit");
+const apiKitBundle = fs.readFileSync(apiKitBundlePath, "utf8");
+
+const networksMatch = apiKitBundle.match(/var networks = (\[[\s\S]*?\n\]);\nvar getNetworkShortName =/);
+if (!networksMatch) {
+  throw new Error(`Unable to locate networks config in ${apiKitBundlePath}`);
+}
+
+const networks = vm.runInNewContext(networksMatch[1]);
+if (!Array.isArray(networks) || networks.length < MIN_EXPECTED_NETWORKS) {
+  throw new Error(`Unexpected networks config shape in ${apiKitBundlePath}`);
+}
+
+const chainIds = [];
+const seenChainIds = new Set();
+
+for (const network of networks) {
+  const chainId = Number(network.chainId);
+  if (!Number.isInteger(chainId)) {
+    throw new Error(`Invalid chainId in ${apiKitBundlePath}: ${network.chainId}`);
+  }
+  if (seenChainIds.has(chainId)) {
+    throw new Error(`Duplicate chainId in ${apiKitBundlePath}: ${chainId}`);
+  }
+
+  seenChainIds.add(chainId);
+  chainIds.push(chainId);
+}
+
+for (const chainId of SUPPORTED_THIRD_PARTY_CHAIN_IDS) {
+  if (seenChainIds.has(chainId)) {
+    throw new Error(`Duplicate supported chainId: ${chainId}`);
+  }
+
+  seenChainIds.add(chainId);
+  chainIds.push(chainId);
+}
+
+const safeDeploymentsRoot = path.dirname(require.resolve("@safe-global/safe-deployments/package.json"));
+const multiSendDeployments = MULTI_SEND_VERSIONS.map((version) => {
+  const deploymentPath = path.join(
+    safeDeploymentsRoot,
+    `src/assets/v${version}/multi_send_call_only.json`,
+  );
+  return JSON.parse(fs.readFileSync(deploymentPath, "utf8"));
+});
+
+const counts = [];
+const addresses = [];
+
+for (const chainId of chainIds) {
+  const validAddresses = new Set();
+
+  for (const deployment of multiSendDeployments) {
+    const addressTypes = deployment.networkAddresses[String(chainId)];
+    if (!addressTypes) {
+      continue;
+    }
+
+    const normalizedAddressTypes = Array.isArray(addressTypes) ? addressTypes : [addressTypes];
+    for (const addressType of normalizedAddressTypes) {
+      const address = deployment.deployments[addressType]?.address;
+      if (typeof address !== "string" || address.length === 0) {
+        throw new Error(`Invalid ${addressType} deployment for chain ${chainId}`);
+      }
+
+      validAddresses.add(address);
+    }
+  }
+
+  if (validAddresses.size === 0) {
+    throw new Error(`No MultiSendCallOnly deployment found for chain ${chainId}`);
+  }
+
+  counts.push(validAddresses.size);
+  addresses.push(...validAddresses);
+}
+
+process.stdout.write(JSON.stringify({ chainIds, counts, addresses }));