@safe-global/safe-deployments 1.36.0 → 1.37.1

package/src/__tests__/assets.test.ts

@@ -1,8 +1,11 @@
-import fs from "fs";
-import path from "path";
+import fs from 'fs';
+import path from 'path';
+import { SingletonDeploymentJSON } from '../types';
+
+const KNOWN_ADDRESS_TYPES = ['canonical', 'eip155', 'zksync'];
 
 function assetPath(...paths: string[]) {
-  return path.join(__dirname, "..", "assets", ...paths);
+  return path.join(__dirname, '..', 'assets', ...paths);
 }
 
 function versions() {
@@ -16,67 +19,93 @@ function versionFiles(version: string) {
 }
 
 async function readAsset(version: string, file: string) {
-  return await fs.promises.readFile(assetPath(version, file), "utf-8");
+  return await fs.promises.readFile(assetPath(version, file), 'utf-8');
 }
 
-async function readAssetJSON(version: string, file: string) {
+async function readAssetJSON(version: string, file: string): Promise<SingletonDeploymentJSON | undefined> {
   return JSON.parse(await readAsset(version, file));
 }
 
-describe("assets/", () => {
+describe('assets/', () => {
   for (const version of versions()) {
     describe(version, () => {
       for (const file of versionFiles(version)) {
         describe(file, () => {
-          describe("networkAddresses", () => {
-            it("should be sorted by chain ID", async () => {
+          describe('networkAddresses', () => {
+            it('should be sorted by chain ID', async () => {
               // We manually parse the JSON here, since ECMA `JSON.parse` will
               // always order fields with numeric keys.
               const json = await readAsset(version, file);
-              const networkAddresses = json
-                .replace(
-                  /^[\s\S]*"networkAddresses" *: *\{([^}]*)\}[\s\S]*$/,
-                  "$1"
-                )
-                .trim();
-              const keys = networkAddresses.split(",").map((pair) => {
-                const [key] = pair.split(":");
-                return parseInt(key.trim().replace(/^"(.*)"$/, "$1"));
+              const networkAddresses = json.replace(/^[\s\S]*"networkAddresses" *: *\{([^}]*)\}[\s\S]*$/, '$1').trim();
+              const keys = networkAddresses.split(',').map((pair) => {
+                const [key] = pair.split(':');
+                return parseInt(key.trim().replace(/^"(.*)"$/, '$1'));
               });
               const sorted = [...keys].sort((a, b) => a - b);
               expect(keys).toEqual(sorted);
             });
 
-            it("should only contain canonical addresses", async () => {
-              const { networkAddresses } = await readAssetJSON(version, file);
-              const canonicalAddresses = [
-                // Ethereum Mainnet address
-                networkAddresses[1],
-                // For v1.3.0, support alternate address with different
-                // `CREATE2` deployer, notably used for Optimism Mainnet
-                ...(version === "v1.3.0" ? [networkAddresses[10]] : []),
-                // zkSync Mainnet address
-                networkAddresses[324],
-              ].filter((address) => address !== undefined);
-
-              for (const [network, address] of Object.entries(
-                networkAddresses
-              )) {
-                expect(
-                  canonicalAddresses.map((address) => [network, address])
-                ).toContainEqual([network, address]);
+            it('networks should only contain canonical address types', async () => {
+              const deploymentJson = await readAssetJSON(version, file);
+              if (!deploymentJson) {
+                throw new Error(`Failed to read asset ${version}/${file}`);
+              }
+
+              const { networkAddresses, addresses } = deploymentJson;
+              const canonicalAddressTypes = Object.keys(addresses);
+
+              for (const addressType of Object.values(networkAddresses)) {
+                if (Array.isArray(addressType)) {
+                  for (const type of addressType) {
+                    expect(canonicalAddressTypes).toContain(type);
+                  }
+                } else {
+                  expect(canonicalAddressTypes).toContain(addressType);
+                }
               }
             });
           });
+
+          it('should only contain known address types', async () => {
+            const deploymentJson = await readAssetJSON(version, file);
+            if (!deploymentJson) {
+              throw new Error(`Failed to read asset ${version}/${file}`);
+            }
+            const { addresses } = deploymentJson;
+
+            for (const addressType of Object.keys(addresses)) {
+              expect(KNOWN_ADDRESS_TYPES).toContain(addressType);
+            }
+          });
+
+          it('no network can contain zksync address together with other address types', async () => {
+            const deploymentJson = await readAssetJSON(version, file);
+            if (!deploymentJson) {
+              throw new Error(`Failed to read asset ${version}/${file}`);
+            }
+            const { networkAddresses } = deploymentJson;
+
+            for (const network of Object.keys(networkAddresses)) {
+              const addressTypes = networkAddresses[network];
+
+              if (Array.isArray(addressTypes)) {
+                expect(addressTypes).not.toContain('zksync');
+              }
+            }
+          });
         });
       }
 
-      describe("networkAddresses", () => {
-        it("should contain the same networks in all files", async () => {
+      describe('networkAddresses', () => {
+        it('should contain the same networks in all files', async () => {
           const files = versionFiles(version);
           const networkCounts: Record<string, number> = {};
           for (const file of files) {
-            const { networkAddresses } = await readAssetJSON(version, file);
+            const deploymentJson = await readAssetJSON(version, file);
+            if (!deploymentJson) {
+              throw new Error(`Failed to read asset ${version}/${file}`);
+            }
+            const { networkAddresses } = deploymentJson;
             for (const network of Object.keys(networkAddresses)) {
               networkCounts[network] = (networkCounts[network] ?? 0) + 1;
             }
@@ -85,6 +114,40 @@ describe("assets/", () => {
             expect([network, count]).toEqual([network, files.length]);
           }
         });
+
+        it('the address types for a network should be the same in all files', async () => {
+          const files = versionFiles(version);
+          const networkAddressMap: Record<string, string | string[]> = {};
+
+          for (const file of files) {
+            const deploymentJson = await readAssetJSON(version, file);
+            if (!deploymentJson) {
+              throw new Error(`Failed to read asset ${version}/${file}`);
+            }
+            const { networkAddresses } = deploymentJson;
+
+            for (const [network, addressTypes] of Object.entries(networkAddresses)) {
+              if (!networkAddressMap[network]) {
+                networkAddressMap[network] = addressTypes;
+              } else {
+                // We use try/catch here to make the error message more readable.
+                // Without it the error message looks like:
+                // Expected: "canonical"
+                // Actual:   ["canonical", "eip155"]
+                try {
+                  expect(addressTypes).toEqual(networkAddressMap[network]);
+                } catch (e) {
+                  console.log(`
+                    Discrepancy in network ${network}
+                    Expected: ${networkAddressMap[network]}
+                    Actual:   ${addressTypes}
+                  `);
+                  throw e;
+                }
+              }
+            }
+          }
+        });
       });
     });
   }

package/src/__tests__/factories.test.ts

@@ -1,12 +1,12 @@
-import ProxyFactory130 from '../assets/v1.3.0/proxy_factory.json';
-import ProxyFactory141 from '../assets/v1.4.1/safe_proxy_factory.json';
+import ProxyFactory130 from './assets/v1/v1.3.0/proxy_factory.json';
+import ProxyFactory141 from './assets/v1/v1.4.1/safe_proxy_factory.json';
 import { getProxyFactoryDeployment } from '../factories';
 
 describe('factories.ts', () => {
   describe('getProxyFactoryDeployment', () => {
     it('should find the latest deployment first', () => {
       const result = getProxyFactoryDeployment();
-      expect(result).toBe(ProxyFactory141);
+      expect(result).toMatchObject(ProxyFactory141);
       expect(result).not.toBe(ProxyFactory130);
     });
   });

package/src/__tests__/handler.test.ts

@@ -1,5 +1,5 @@
-import DefaultCallbackHandler130 from '../assets/v1.1.1/default_callback_handler.json';
-import CompatibilityFallbackHandler141 from '../assets/v1.4.1/compatibility_fallback_handler.json';
+import DefaultCallbackHandler130 from './assets/v1/v1.1.1/default_callback_handler.json';
+import CompatibilityFallbackHandler141 from './assets/v1/v1.4.1/compatibility_fallback_handler.json';
 import {
   getDefaultCallbackHandlerDeployment,
   getCompatibilityFallbackHandlerDeployment,
@@ -10,21 +10,21 @@ describe('handler.ts', () => {
   describe('getDefaultCallbackHandlerDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getDefaultCallbackHandlerDeployment();
-      expect(result).toBe(DefaultCallbackHandler130);
+      expect(result).toMatchObject(DefaultCallbackHandler130);
     });
   });
 
   describe('getCompatibilityFallbackHandlerDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getCompatibilityFallbackHandlerDeployment();
-      expect(result).toBe(CompatibilityFallbackHandler141);
+      expect(result).toMatchObject(CompatibilityFallbackHandler141);
     });
   });
 
   describe('getFallbackHandlerDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getFallbackHandlerDeployment();
-      expect(result).toBe(CompatibilityFallbackHandler141);
+      expect(result).toMatchObject(CompatibilityFallbackHandler141);
       expect(result).not.toBe(DefaultCallbackHandler130);
     });
   });

package/src/__tests__/libs.test.ts

@@ -1,8 +1,8 @@
-import CreateCall141 from '../assets/v1.4.1/create_call.json';
-import MultiSend111 from '../assets/v1.1.1/multi_send.json';
-import MultiSend141 from '../assets/v1.4.1/multi_send.json';
-import MultiSendCallOnly141 from '../assets/v1.4.1/multi_send_call_only.json';
-import SignMessageLib141 from '../assets/v1.4.1/sign_message_lib.json';
+import CreateCall141 from './assets/v1/v1.4.1/create_call.json';
+import MultiSend111 from './assets/v1/v1.1.1/multi_send.json';
+import MultiSend141 from './assets/v1/v1.4.1/multi_send.json';
+import MultiSendCallOnly141 from './assets/v1/v1.4.1/multi_send_call_only.json';
+import SignMessageLib141 from './assets/v1/v1.4.1/sign_message_lib.json';
 import {
   getMultiSendDeployment,
   getMultiSendCallOnlyDeployment,
@@ -14,26 +14,26 @@ describe('libs.ts', () => {
   describe('getMultiSendDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getMultiSendDeployment();
-      expect(result).toBe(MultiSend141);
+      expect(result).toMatchObject(MultiSend141);
       expect(result).not.toBe(MultiSend111);
     });
   });
   describe('getMultiSendCallOnlyDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getMultiSendCallOnlyDeployment();
-      expect(result).toBe(MultiSendCallOnly141);
+      expect(result).toMatchObject(MultiSendCallOnly141);
     });
   });
   describe('getCreateCallDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getCreateCallDeployment();
-      expect(result).toBe(CreateCall141);
+      expect(result).toMatchObject(CreateCall141);
     });
   });
   describe('getSignMessageLibDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getSignMessageLibDeployment();
-      expect(result).toBe(SignMessageLib141);
+      expect(result).toMatchObject(SignMessageLib141);
     });
   });
 });

package/src/__tests__/safes.test.ts

@@ -1,19 +1,16 @@
-import SafeL2141 from '../assets/v1.4.1/safe_l2.json';
-import Safe141 from '../assets/v1.4.1/safe.json';
-import GnosisSafe130 from '../assets/v1.3.0/gnosis_safe.json';
-import GnosisSafe120 from '../assets/v1.2.0/gnosis_safe.json';
-import GnosisSafe111 from '../assets/v1.1.1/gnosis_safe.json';
-import GnosisSafe100 from '../assets/v1.0.0/gnosis_safe.json';
-import {
-  getSafeSingletonDeployment,
-  getSafeL2SingletonDeployment,
-} from '../safes';
+import SafeL2141 from './assets/v1/v1.4.1/safe_l2.json';
+import Safe141 from './assets/v1/v1.4.1/safe.json';
+import GnosisSafe130 from './assets/v1/v1.3.0/gnosis_safe.json';
+import GnosisSafe120 from './assets/v1/v1.2.0/gnosis_safe.json';
+import GnosisSafe111 from './assets/v1/v1.1.1/gnosis_safe.json';
+import GnosisSafe100 from './assets/v1/v1.0.0/gnosis_safe.json';
+import { getSafeSingletonDeployment, getSafeL2SingletonDeployment } from '../safes';
 
 describe('safes.ts', () => {
   describe('getSafeSingletonDeployment', () => {
     it('should find the latest deployment first', () => {
       const result = getSafeSingletonDeployment();
-      expect(result).toBe(Safe141);
+      expect(result).toMatchObject(Safe141);
       [GnosisSafe130, GnosisSafe120, GnosisSafe111, GnosisSafe100].forEach((version) => {
         expect(result).not.toBe(version);
       });
@@ -22,7 +19,7 @@ describe('safes.ts', () => {
   describe('getSafeL2SingletonDeployment', () => {
     it('should find the latest deployment first', () => {
       const result = getSafeL2SingletonDeployment();
-      expect(result).toBe(SafeL2141);
+      expect(result).toMatchObject(SafeL2141);
     });
   });
 });

package/src/__tests__/utils.test.ts

@@ -0,0 +1,271 @@
+import SafeL2141 from './assets/v1/v1.4.1/safe_l2.json';
+import Safe141 from './assets/v1/v1.4.1/safe.json';
+
+import GnosisSafeL2130 from './assets/v1/v1.3.0/gnosis_safe_l2.json';
+import GnosisSafe130 from './assets/v1/v1.3.0/gnosis_safe.json';
+import GnosisSafe120 from './assets/v1/v1.2.0/gnosis_safe.json';
+import GnosisSafe111 from './assets/v1/v1.1.1/gnosis_safe.json';
+import GnosisSafe100 from './assets/v1/v1.0.0/gnosis_safe.json';
+import { findDeployment } from '../utils';
+import { _safeDeployments, _safeL2Deployments } from '../safes';
+import { SingletonDeployment, SingletonDeploymentJSON } from '../types';
+
+const _safeDeploymentsReverse = [..._safeDeployments].reverse();
+
+describe('utils.ts', () => {
+  describe('findDeployment', () => {
+    it('should filter by released by default', () => {
+      const testUnreleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: false,
+      };
+      const testReleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: true, // Default filter value
+      };
+      const testReleasedDeployment: SingletonDeployment = {
+        defaultAddress: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef' },
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: true,
+        abi: [],
+        version: '',
+        contractName: '',
+      };
+
+      const testDeployments = [testUnreleasedDeploymentJson, testUnreleasedDeploymentJson, testReleasedDeploymentJson];
+
+      expect(findDeployment(undefined, testDeployments)).toMatchObject(testReleasedDeployment);
+
+      // should preserve the released flag even if its not explicitly passed
+      expect(findDeployment({ network: '1' }, testDeployments)).toMatchObject(testReleasedDeployment);
+    });
+
+    it('should return the correct deployment (filtered by version)', () => {
+      // Chronological deployments
+      expect(findDeployment({ version: '1.3.0' }, _safeDeployments)).toMatchObject(GnosisSafe130);
+      expect(findDeployment({ version: '1.2.0' }, _safeDeployments)).toMatchObject(GnosisSafe120);
+      expect(findDeployment({ version: '1.1.1' }, _safeDeployments)).toMatchObject(GnosisSafe111);
+      expect(findDeployment({ version: '1.0.0' }, _safeDeployments)).toMatchObject(GnosisSafe100);
+      // Incorrect filter:
+      expect(findDeployment({ version: '2.0.0' }, _safeDeployments)).toBeUndefined();
+
+      // L2 deployments
+      expect(findDeployment({ version: '1.3.0+L2' }, _safeL2Deployments)).toMatchObject(GnosisSafeL2130);
+      // Incorrect filter:
+      expect(findDeployment({ version: '2.0.0+L2' }, _safeL2Deployments)).toBeUndefined();
+    });
+
+    it('should return the correct deployment (filtered by released flag)', () => {
+      const testUnreleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: false,
+      };
+      const testReleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: true, // Default filter value
+      };
+      const testUnreleasedDeployment: SingletonDeployment = {
+        defaultAddress: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef' },
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: false,
+        abi: [],
+        version: '',
+        contractName: '',
+      };
+
+      const testDeployments = [testUnreleasedDeploymentJson, testReleasedDeploymentJson];
+
+      // Chronological deployments
+      expect(findDeployment({ released: true }, _safeDeployments)).toMatchObject(Safe141);
+
+      // Reverse chronological deployments
+      expect(findDeployment({ released: true }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe100);
+      // Released flag set to false:
+      expect(findDeployment({ released: false }, testDeployments)).toMatchObject(testUnreleasedDeployment);
+
+      // L2 deployments
+      expect(findDeployment({ released: true }, _safeL2Deployments)).toMatchObject(SafeL2141);
+    });
+
+    it('should return the correct deployment (filtered by network)', () => {
+      // Reverse chronological deployments
+      expect(findDeployment({ network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe100);
+      expect(findDeployment({ network: '73799' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe111);
+      expect(findDeployment({ network: '11297108109' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe130);
+      // Incorrect filter:
+      expect(findDeployment({ network: '0' }, _safeDeploymentsReverse)).toBeUndefined();
+
+      // L2 deployments
+      expect(findDeployment({ network: '100' }, _safeL2Deployments)).toMatchObject(SafeL2141);
+      // Incorrect filter:
+      expect(findDeployment({ network: '0' }, _safeL2Deployments)).toBeUndefined();
+    });
+    it('should return the correct deployment (filtered by version and released)', () => {
+      // Chronological deployments
+      expect(findDeployment({ version: '1.3.0', released: true }, _safeDeployments)).toMatchObject(GnosisSafe130);
+      expect(findDeployment({ version: '1.2.0', released: true }, _safeDeployments)).toMatchObject(GnosisSafe120);
+      expect(findDeployment({ version: '1.1.1', released: true }, _safeDeployments)).toMatchObject(GnosisSafe111);
+      expect(findDeployment({ version: '1.0.0', released: true }, _safeDeployments)).toMatchObject(GnosisSafe100);
+      // Incorrect filter:
+      expect(findDeployment({ version: '1.0.0', released: false }, _safeDeployments)).toBeUndefined();
+
+      // L2 deployments
+      expect(findDeployment({ version: '1.3.0', released: true }, _safeL2Deployments)).toMatchObject(GnosisSafeL2130);
+      expect(findDeployment({ version: '1.3.0+L2', released: true }, _safeL2Deployments)).toMatchObject(
+        GnosisSafeL2130,
+      );
+      // Incorrect filter:
+      expect(findDeployment({ version: '1.3.0+L2', released: false }, _safeL2Deployments)).toBeUndefined();
+    });
+    it('should return the correct deployment (filtered by version and network)', () => {
+      // Reverse chronological deployments
+      expect(findDeployment({ version: '1.0.0', network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe100);
+      expect(findDeployment({ version: '1.1.1', network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe111);
+      expect(findDeployment({ version: '1.2.0', network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe120);
+      expect(findDeployment({ version: '1.3.0', network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe130);
+      // Incorrect filter:
+      expect(findDeployment({ version: '1.3.0', network: '0' }, _safeDeploymentsReverse)).toBeUndefined();
+
+      // L2 deployments
+      expect(findDeployment({ version: '1.3.0', network: '100' }, _safeL2Deployments)).toMatchObject(GnosisSafeL2130);
+      expect(findDeployment({ version: '1.3.0+L2', network: '100' }, _safeL2Deployments)).toMatchObject(
+        GnosisSafeL2130,
+      );
+      // Incorrect filter:
+      expect(findDeployment({ version: '1.3.0+L2', network: '0' }, _safeL2Deployments)).toBeUndefined();
+    });
+    it('should return the correct deployment (filtered by released and network)', () => {
+      const testUnreleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: false,
+      };
+      const testReleasedDeploymentJson: SingletonDeploymentJSON = {
+        version: '',
+        abi: [],
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': 'canonical' },
+        contractName: '',
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: true, // Default filter value
+      };
+      const testUnreleasedDeployment: SingletonDeployment = {
+        defaultAddress: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        addresses: {
+          canonical: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+        },
+        networkAddresses: { '1': '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef' },
+        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        released: false,
+        abi: [],
+        version: '',
+        contractName: '',
+      };
+
+      const testDeployments = [testUnreleasedDeploymentJson, testUnreleasedDeploymentJson, testReleasedDeploymentJson];
+
+      // Reverse chronological deployments
+      expect(findDeployment({ released: true, network: '1' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe100);
+      expect(findDeployment({ released: true, network: '246' }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe111);
+      expect(findDeployment({ released: true, network: '11297108109' }, _safeDeploymentsReverse)).toMatchObject(
+        GnosisSafe130,
+      );
+      // Incorrect filter:
+      expect(findDeployment({ released: true, network: '0' }, _safeDeploymentsReverse)).toBeUndefined();
+      expect(findDeployment({ released: false, network: '1' }, testDeployments)).toMatchObject(
+        testUnreleasedDeployment,
+      );
+
+      // L2 deployments
+      expect(findDeployment({ released: true, network: '100' }, _safeL2Deployments)).toMatchObject(SafeL2141);
+      // Incorrect filter:
+      expect(findDeployment({ released: true, network: '0' }, _safeL2Deployments)).toBeUndefined();
+      expect(findDeployment({ released: false, network: '100' }, testDeployments)).toBeUndefined();
+    });
+    it('should return the correct deployment (filtered by version, released and network)', () => {
+      // Reverse chronological deployments
+      expect(findDeployment({ version: '1.0.0', released: true, network: '1' }, _safeDeploymentsReverse)).toMatchObject(
+        GnosisSafe100,
+      );
+      expect(
+        findDeployment({ version: '1.1.1', released: true, network: '246' }, _safeDeploymentsReverse),
+      ).toMatchObject(GnosisSafe111);
+      expect(
+        findDeployment({ version: '1.2.0', released: true, network: '73799' }, _safeDeploymentsReverse),
+      ).toMatchObject(GnosisSafe120);
+      expect(
+        findDeployment({ version: '1.3.0', released: true, network: '11297108109' }, _safeDeploymentsReverse),
+      ).toMatchObject(GnosisSafe130);
+      // Incorrect filter:
+      expect(
+        findDeployment({ version: '1.3.0', released: false, network: '11297108109' }, _safeDeploymentsReverse),
+      ).toBeUndefined();
+      expect(
+        findDeployment({ version: '1.3.0', released: true, network: '0' }, _safeDeploymentsReverse),
+      ).toBeUndefined();
+      expect(
+        findDeployment({ version: '2.0.0', released: true, network: '11297108109' }, _safeDeploymentsReverse),
+      ).toBeUndefined();
+
+      // L2 deployments
+      expect(findDeployment({ version: '1.3.0', released: true, network: '100' }, _safeL2Deployments)).toMatchObject(
+        GnosisSafeL2130,
+      );
+      expect(findDeployment({ version: '1.3.0+L2', released: true, network: '100' }, _safeL2Deployments)).toMatchObject(
+        GnosisSafeL2130,
+      );
+      // Incorrect filter:
+      expect(
+        findDeployment({ version: '1.3.0+L2', released: false, network: '100' }, _safeL2Deployments),
+      ).toBeUndefined();
+      expect(findDeployment({ version: '1.3.0+L2', released: true, network: '0' }, _safeL2Deployments)).toBeUndefined();
+      expect(
+        findDeployment({ version: '2.0.0+L2', released: true, network: '100' }, _safeL2Deployments),
+      ).toBeUndefined();
+    });
+  });
+});

package/src/accessors.ts

@@ -1,14 +1,12 @@
 import SimulateTxAccessor130 from './assets/v1.3.0/simulate_tx_accessor.json';
 import SimulateTxAccessor141 from './assets/v1.4.1/simulate_tx_accessor.json';
 
-import { DeploymentFilter, SingletonDeployment } from './types'
-import { findDeployment } from './utils'
+import { DeploymentFilter, SingletonDeploymentJSON, SingletonDeployment } from './types';
+import { findDeployment } from './utils';
 
 // This is a sorted array (newest to oldest)
-const accessorDeployments: SingletonDeployment[] = [
-    SimulateTxAccessor141, SimulateTxAccessor130
-]
+const accessorDeployments: SingletonDeploymentJSON[] = [SimulateTxAccessor141, SimulateTxAccessor130];
 
 export const getSimulateTxAccessorDeployment = (filter?: DeploymentFilter): SingletonDeployment | undefined => {
-    return findDeployment(filter, accessorDeployments)
-}
+  return findDeployment(filter, accessorDeployments);
+};