@safe-global/safe-deployments 1.37.35 → 1.37.37

package/src/__tests__/libs.test.ts

@@ -1,8 +1,7 @@
-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 CreateCall from '../assets/v1.5.0/create_call.json';
+import MultiSend from '../assets/v1.5.0/multi_send.json';
+import MultiSendCallOnly from '../assets/v1.5.0/multi_send_call_only.json';
+import SignMessageLib from '../assets/v1.5.0/sign_message_lib.json';
 import {
   getMultiSendDeployment,
   getMultiSendCallOnlyDeployment,
@@ -14,26 +13,60 @@ describe('libs.ts', () => {
   describe('getMultiSendDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getMultiSendDeployment();
-      expect(result).toMatchObject(MultiSend141);
-      expect(result).not.toBe(MultiSend111);
+      expect(result).toMatchObject({
+        defaultAddress: MultiSend.deployments.canonical.address,
+        contractName: 'MultiSend',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: MultiSend.deployments.canonical.address,
+        },
+        abi: MultiSend.abi,
+      });
     });
   });
+
   describe('getMultiSendCallOnlyDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getMultiSendCallOnlyDeployment();
-      expect(result).toMatchObject(MultiSendCallOnly141);
+      expect(result).toMatchObject({
+        defaultAddress: MultiSendCallOnly.deployments.canonical.address,
+        contractName: 'MultiSendCallOnly',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: MultiSendCallOnly.deployments.canonical.address,
+        },
+        abi: MultiSendCallOnly.abi,
+      });
     });
   });
+
   describe('getCreateCallDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getCreateCallDeployment();
-      expect(result).toMatchObject(CreateCall141);
+      expect(result).toMatchObject({
+        defaultAddress: CreateCall.deployments.canonical.address,
+        contractName: 'CreateCall',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: CreateCall.deployments.canonical.address,
+        },
+        abi: CreateCall.abi,
+      });
     });
   });
+
   describe('getSignMessageLibDeployment', () => {
     it('should find the preferred deployment first', () => {
       const result = getSignMessageLibDeployment();
-      expect(result).toMatchObject(SignMessageLib141);
+      expect(result).toMatchObject({
+        defaultAddress: SignMessageLib.deployments.canonical.address,
+        contractName: 'SignMessageLib',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: SignMessageLib.deployments.canonical.address,
+        },
+        abi: SignMessageLib.abi,
+      });
     });
   });
 });

package/src/__tests__/safes.test.ts

@@ -1,25 +1,85 @@
-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 Safe150 from '../assets/v1.5.0/safe.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 SafeL2150 from '../assets/v1.5.0/safe_l2.json';
+import SafeL2141 from '../assets/v1.4.1/safe_l2.json';
+import GnosisSafeL2130 from '../assets/v1.3.0/gnosis_safe_l2.json';
 import { getSafeSingletonDeployment, getSafeL2SingletonDeployment } from '../safes';
 
 describe('safes.ts', () => {
   describe('getSafeSingletonDeployment', () => {
     it('should find the latest deployment first', () => {
       const result = getSafeSingletonDeployment();
-      expect(result).toMatchObject(Safe141);
-      [GnosisSafe130, GnosisSafe120, GnosisSafe111, GnosisSafe100].forEach((version) => {
-        expect(result).not.toBe(version);
+      expect(result).toMatchObject({
+        defaultAddress: Safe150.deployments.canonical.address,
+        contractName: 'Safe',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: Safe150.deployments.canonical.address,
+        },
+        abi: Safe150.abi,
       });
     });
+
+    it('should return the correct deployment filtered by version', () => {
+      for (const [version, artifact] of [
+        ['1.5.0', Safe150],
+        ['1.4.1', Safe141],
+        ['1.3.0', GnosisSafe130],
+        ['1.2.0', GnosisSafe120],
+        ['1.1.1', GnosisSafe111],
+        ['1.0.0', GnosisSafe100],
+      ] as const) {
+        expect(getSafeSingletonDeployment({ version })).toMatchObject({
+          defaultAddress: artifact.deployments.canonical.address,
+          contractName: artifact.contractName,
+          version,
+          networkAddresses: {
+            ['1']: artifact.deployments.canonical.address,
+          },
+          abi: artifact.abi,
+        });
+      }
+
+      expect(getSafeSingletonDeployment({ version: '99.0.0' })).toBeUndefined();
+    });
   });
+
   describe('getSafeL2SingletonDeployment', () => {
     it('should find the latest deployment first', () => {
       const result = getSafeL2SingletonDeployment();
-      expect(result).toMatchObject(SafeL2141);
+      expect(result).toMatchObject({
+        defaultAddress: SafeL2150.deployments.canonical.address,
+        contractName: 'SafeL2',
+        version: '1.5.0',
+        networkAddresses: {
+          ['1']: SafeL2150.deployments.canonical.address,
+        },
+        abi: SafeL2150.abi,
+      });
+    });
+
+    it('should return the correct deployment filtered by version', () => {
+      for (const [version, artifact] of [
+        ['1.5.0', SafeL2150],
+        ['1.4.1', SafeL2141],
+        ['1.3.0', GnosisSafeL2130],
+      ] as const) {
+        expect(getSafeL2SingletonDeployment({ version })).toMatchObject({
+          defaultAddress: artifact.deployments.canonical.address,
+          contractName: artifact.contractName,
+          version,
+          networkAddresses: {
+            ['1']: artifact.deployments.canonical.address,
+          },
+          abi: artifact.abi,
+        });
+      }
+
+      expect(getSafeL2SingletonDeployment({ version: '99.0.0' })).toBeUndefined();
     });
   });
 });

package/src/__tests__/utils.test.ts

@@ -1,11 +1,3 @@
-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 { _SAFE_DEPLOYMENTS, _SAFE_L2_DEPLOYMENTS } from '../deployments';
 import { SingletonDeployment, SingletonDeploymentJSON, DeploymentFormats, SingletonDeploymentV2 } from '../types';
@@ -21,7 +13,7 @@ describe('utils.ts', () => {
           abi: [],
           deployments: {
             canonical: {
-              address: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+              address: '0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead',
               codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
             },
           },
@@ -69,28 +61,13 @@ describe('utils.ts', () => {
         expect(findDeployment({ network: '1' }, testDeployments)).toMatchObject(testReleasedDeployment);
       });
 
-      it('should return the correct deployment (filtered by version)', () => {
-        // Chronological deployments
-        expect(findDeployment({ version: '1.3.0' }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe130);
-        expect(findDeployment({ version: '1.2.0' }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe120);
-        expect(findDeployment({ version: '1.1.1' }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe111);
-        expect(findDeployment({ version: '1.0.0' }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe100);
-        // Incorrect filter:
-        expect(findDeployment({ version: '2.0.0' }, _SAFE_DEPLOYMENTS)).toBeUndefined();
-
-        // L2 deployments
-        expect(findDeployment({ version: '1.3.0+L2' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(GnosisSafeL2130);
-        // Incorrect filter:
-        expect(findDeployment({ version: '2.0.0+L2' }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
-      });
-
       it('should return the correct deployment (filtered by released flag)', () => {
         const testUnreleasedDeploymentJson: SingletonDeploymentJSON = {
           version: '',
           abi: [],
           deployments: {
             canonical: {
-              address: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
+              address: '0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead',
               codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
             },
           },
@@ -112,6 +89,20 @@ describe('utils.ts', () => {
           released: true, // Default filter value
         };
         const testUnreleasedDeployment: SingletonDeployment = {
+          defaultAddress: '0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead',
+          deployments: {
+            canonical: {
+              address: '0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead',
+              codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            },
+          },
+          networkAddresses: { '1': '0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead' },
+          released: false,
+          abi: [],
+          version: '',
+          contractName: '',
+        };
+        const testReleasedDeployment: SingletonDeployment = {
           defaultAddress: '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef',
           deployments: {
             canonical: {
@@ -120,64 +111,91 @@ describe('utils.ts', () => {
             },
           },
           networkAddresses: { '1': '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef' },
-          released: false,
+          released: true,
           abi: [],
           version: '',
           contractName: '',
         };
-
         const testDeployments = [testUnreleasedDeploymentJson, testReleasedDeploymentJson];
 
-        // Chronological deployments
-        expect(findDeployment({ released: true }, _SAFE_DEPLOYMENTS)).toMatchObject(Safe141);
-
-        // Reverse chronological deployments
-        expect(findDeployment({ released: true }, _safeDeploymentsReverse)).toMatchObject(GnosisSafe100);
-        // Released flag set to false:
         expect(findDeployment({ released: false }, testDeployments)).toMatchObject(testUnreleasedDeployment);
+        expect(findDeployment({ released: true }, testDeployments)).toMatchObject(testReleasedDeployment);
 
-        // L2 deployments
-        expect(findDeployment({ released: true }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(SafeL2141);
+        expect(findDeployment({ released: true }, _SAFE_DEPLOYMENTS)).toMatchObject({
+          contractName: 'Safe',
+          version: '1.5.0',
+        });
+        expect(findDeployment({ released: true }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+        });
+        expect(findDeployment({ released: true }, _SAFE_L2_DEPLOYMENTS)).toMatchObject({
+          contractName: 'SafeL2',
+          version: '1.5.0',
+        });
       });
 
       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);
+        expect(findDeployment({ network: '1' }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+        });
+        expect(findDeployment({ network: '73799' }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.1.1',
+        });
+        expect(findDeployment({ network: '11297108109' }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.3.0',
+        });
         // Incorrect filter:
         expect(findDeployment({ network: '0' }, _safeDeploymentsReverse)).toBeUndefined();
 
         // L2 deployments
-        expect(findDeployment({ network: '100' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(SafeL2141);
+        expect(findDeployment({ network: '1' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject({
+          contractName: 'SafeL2',
+          version: '1.5.0',
+        });
         // Incorrect filter:
         expect(findDeployment({ network: '0' }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
       });
+
       it('should return the correct deployment (filtered by version and released)', () => {
         // Chronological deployments
-        expect(findDeployment({ version: '1.3.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe130);
-        expect(findDeployment({ version: '1.2.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe120);
-        expect(findDeployment({ version: '1.1.1', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe111);
-        expect(findDeployment({ version: '1.0.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject(GnosisSafe100);
+        expect(findDeployment({ version: '1.3.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.3.0',
+          released: true,
+        });
+        expect(findDeployment({ version: '1.2.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.2.0',
+          released: true,
+        });
+        expect(findDeployment({ version: '1.1.1', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.1.1',
+          released: true,
+        });
+        expect(findDeployment({ version: '1.0.0', released: true }, _SAFE_DEPLOYMENTS)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+          released: true,
+        });
         // Incorrect filter:
         expect(findDeployment({ version: '1.0.0', released: false }, _SAFE_DEPLOYMENTS)).toBeUndefined();
 
         // L2 deployments
-        expect(
-          findDeployment(
-            {
-              version: '1.3.0',
-              released: true,
-            },
-            _SAFE_L2_DEPLOYMENTS,
-          ),
-        ).toMatchObject(GnosisSafeL2130);
-        expect(findDeployment({ version: '1.3.0+L2', released: true }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(
-          GnosisSafeL2130,
-        );
+        expect(findDeployment({ version: '1.3.0', released: true }, _SAFE_L2_DEPLOYMENTS)).toMatchObject({
+          contractName: 'GnosisSafeL2',
+          version: '1.3.0',
+          released: true,
+        });
         // Incorrect filter:
-        expect(findDeployment({ version: '1.3.0+L2', released: false }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
+        expect(findDeployment({ version: '1.3.0', released: false }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
       });
+
       it('should return the correct deployment (filtered by version and network)', () => {
         // Reverse chronological deployments
         expect(
@@ -188,7 +206,10 @@ describe('utils.ts', () => {
             },
             _safeDeploymentsReverse,
           ),
-        ).toMatchObject(GnosisSafe100);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+        });
         expect(
           findDeployment(
             {
@@ -197,7 +218,10 @@ describe('utils.ts', () => {
             },
             _safeDeploymentsReverse,
           ),
-        ).toMatchObject(GnosisSafe111);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.1.1',
+        });
         expect(
           findDeployment(
             {
@@ -206,7 +230,10 @@ describe('utils.ts', () => {
             },
             _safeDeploymentsReverse,
           ),
-        ).toMatchObject(GnosisSafe120);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.2.0',
+        });
         expect(
           findDeployment(
             {
@@ -215,7 +242,10 @@ describe('utils.ts', () => {
             },
             _safeDeploymentsReverse,
           ),
-        ).toMatchObject(GnosisSafe130);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.3.0',
+        });
         // Incorrect filter:
         expect(findDeployment({ version: '1.3.0', network: '0' }, _safeDeploymentsReverse)).toBeUndefined();
 
@@ -228,13 +258,14 @@ describe('utils.ts', () => {
             },
             _SAFE_L2_DEPLOYMENTS,
           ),
-        ).toMatchObject(GnosisSafeL2130);
-        expect(findDeployment({ version: '1.3.0+L2', network: '100' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(
-          GnosisSafeL2130,
-        );
+        ).toMatchObject({
+          contractName: 'GnosisSafeL2',
+          version: '1.3.0',
+        });
         // Incorrect filter:
-        expect(findDeployment({ version: '1.3.0+L2', network: '0' }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
+        expect(findDeployment({ version: '1.3.0', network: '0' }, _SAFE_L2_DEPLOYMENTS)).toBeUndefined();
       });
+
       it('should return the correct deployment (filtered by released and network)', () => {
         const testUnreleasedDeploymentJson: SingletonDeploymentJSON = {
           version: '',
@@ -283,6 +314,10 @@ describe('utils.ts', () => {
           testReleasedDeploymentJson,
         ];
 
+        expect(findDeployment({ released: false, network: '1' }, testDeployments)).toMatchObject(
+          testUnreleasedDeployment,
+        );
+
         // Reverse chronological deployments
         expect(
           findDeployment(
@@ -292,39 +327,57 @@ describe('utils.ts', () => {
             },
             _safeDeploymentsReverse,
           ),
-        ).toMatchObject(GnosisSafe100);
-        expect(findDeployment({ released: true, network: '246' }, _safeDeploymentsReverse)).toMatchObject(
-          GnosisSafe111,
-        );
-        expect(findDeployment({ released: true, network: '11297108109' }, _safeDeploymentsReverse)).toMatchObject(
-          GnosisSafe130,
-        );
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+        });
+        expect(findDeployment({ released: true, network: '246' }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.1.1',
+        });
+        expect(findDeployment({ released: true, network: '11297108109' }, _safeDeploymentsReverse)).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.3.0',
+        });
         // 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' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject(SafeL2141);
+        expect(findDeployment({ released: true, network: '1' }, _SAFE_L2_DEPLOYMENTS)).toMatchObject({
+          contractName: 'SafeL2',
+          version: '1.5.0',
+        });
         // Incorrect filter:
         expect(findDeployment({ released: true, network: '0' }, _SAFE_L2_DEPLOYMENTS)).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);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.0.0',
+        });
         expect(
           findDeployment({ version: '1.1.1', released: true, network: '246' }, _safeDeploymentsReverse),
-        ).toMatchObject(GnosisSafe111);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.1.1',
+        });
         expect(
           findDeployment({ version: '1.2.0', released: true, network: '73799' }, _safeDeploymentsReverse),
-        ).toMatchObject(GnosisSafe120);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.2.0',
+        });
         expect(
           findDeployment({ version: '1.3.0', released: true, network: '11297108109' }, _safeDeploymentsReverse),
-        ).toMatchObject(GnosisSafe130);
+        ).toMatchObject({
+          contractName: 'GnosisSafe',
+          version: '1.3.0',
+        });
         // Incorrect filter:
         expect(
           findDeployment({ version: '1.3.0', released: false, network: '11297108109' }, _safeDeploymentsReverse),
@@ -338,27 +391,20 @@ describe('utils.ts', () => {
 
         // L2 deployments
         expect(
-          findDeployment(
-            {
-              version: '1.3.0',
-              released: true,
-              network: '100',
-            },
-            _SAFE_L2_DEPLOYMENTS,
-          ),
-        ).toMatchObject(GnosisSafeL2130);
-        expect(
-          findDeployment({ version: '1.3.0+L2', released: true, network: '100' }, _SAFE_L2_DEPLOYMENTS),
-        ).toMatchObject(GnosisSafeL2130);
+          findDeployment({ version: '1.3.0', released: true, network: '100' }, _SAFE_L2_DEPLOYMENTS),
+        ).toMatchObject({
+          contractName: 'GnosisSafeL2',
+          version: '1.3.0',
+        });
         // Incorrect filter:
         expect(
-          findDeployment({ version: '1.3.0+L2', released: false, network: '100' }, _SAFE_L2_DEPLOYMENTS),
+          findDeployment({ version: '1.3.0', released: false, network: '100' }, _SAFE_L2_DEPLOYMENTS),
         ).toBeUndefined();
         expect(
-          findDeployment({ version: '1.3.0+L2', released: true, network: '0' }, _SAFE_L2_DEPLOYMENTS),
+          findDeployment({ version: '1.3.0', released: true, network: '0' }, _SAFE_L2_DEPLOYMENTS),
         ).toBeUndefined();
         expect(
-          findDeployment({ version: '2.0.0+L2', released: true, network: '100' }, _SAFE_L2_DEPLOYMENTS),
+          findDeployment({ version: '2.0.0', released: true, network: '100' }, _SAFE_L2_DEPLOYMENTS),
         ).toBeUndefined();
       });
     });