12297570138

Committed 12 Dec 2024 01:36PM UTC coverage: 90.13% (-0.01%) from 90.141%

Build # 12297570138

Build Type

Pull #2192

github

Committed by

PooyaRaki

Commit Message

fix tests

Pull Request Pull Request #2192: Fix notification message address recovery bug, Validate notification …

Run Details

2817 of 3504 branches covered (80.39%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

9630 of 10306 relevant lines covered (93.44%)

435.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.7

/src/routes/notifications/v1/notifications.controller.ts

import {
  BadRequestException,
  Body,
  Controller,
  Delete,
  HttpCode,
  Inject,
  NotFoundException,
  Param,
  Post,
} from '@nestjs/common';
import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
import { RegisterDeviceDto } from '@/routes/notifications/v1/entities/register-device.dto.entity';
import { NotificationsService } from '@/routes/notifications/v1/notifications.service';
import { ValidationPipe } from '@/validation/pipes/validation.pipe';
import { AddressSchema } from '@/validation/entities/schemas/address.schema';
import type { UpsertSubscriptionsSafesDto } from '@/routes/notifications/v2/entities/upsert-subscriptions.dto.entity';
import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
import { NotificationType } from '@/domain/notifications/v2/entities/notification.entity';
import type { UUID } from 'crypto';
import { NotificationsServiceV2 } from '@/routes/notifications/v2/notifications.service';
import { keccak256, recoverMessageAddress, toBytes } from 'viem';
import { UuidSchema } from '@/validation/entities/schemas/uuid.schema';
import { IConfigurationService } from '@/config/configuration.service.interface';
import {
  LoggingService,
  type ILoggingService,
} from '@/logging/logging.interface';

@ApiTags('notifications')
@Controller({ path: '', version: '1' })
export class NotificationsController {
  private static REGISTRATION_TIMESTAMP_EXPIRY = 5 * 60;
  private isPushNotificationV2Enabled: boolean;
  constructor(
    // Adding NotificationServiceV2 to ensure compatibility with V1.
    // @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
    @Inject(NotificationsServiceV2)
    private readonly notificationServiceV2: NotificationsServiceV2,
    private readonly notificationsService: NotificationsService,

    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,

    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
  ) {
    this.isPushNotificationV2Enabled =
      this.configurationService.getOrThrow<boolean>(
        'features.pushNotifications',
      );
  }

  @ApiOkResponse()
  @Post('register/notifications')
  @HttpCode(200)
  async registerDevice(
    @Body() registerDeviceDto: RegisterDeviceDto,
  ): Promise<void> {
    if (!this.isPushNotificationV2Enabled) {
      return await this.notificationsService.registerDevice(registerDeviceDto);
    }

    if (registerDeviceDto.timestamp) {
      this.validateTimestamp(parseInt(registerDeviceDto.timestamp));
    }

    // Compatibility with V2
    const compatibleV2Requests =
      await this.createV2RegisterDto(registerDeviceDto);

    const v2Requests = [];

    for (const compatibleV2Request of compatibleV2Requests) {
      v2Requests.push(
        await this.notificationServiceV2.upsertSubscriptions(
          compatibleV2Request,
        ),
      );
    }
    await Promise.all(v2Requests);

    // Remove tokens from the old service to prevent duplication.
    if (registerDeviceDto.uuid) {
      const unregistrationRequests = [];
      for (const safeRegistration of registerDeviceDto.safeRegistrations) {
        unregistrationRequests.push(
          this.notificationsService.unregisterDevice({
            chainId: safeRegistration.chainId,
            uuid: registerDeviceDto.uuid,
          }),
        );
      }

      await Promise.allSettled(unregistrationRequests).then(
        (results: Array<PromiseSettledResult<unknown>>) => {
          for (const result of results) {
            // If the device is not already registered, the TX service will throw a 404 error, but we can safely ignore it.
            if (
              result.status === 'rejected' &&
              'code' in result.reason &&
              result.reason.code !== 404
            ) {
              this.loggingService.error(result.reason);
            }
          }
        },
      );
    }
  }

  private async createV2RegisterDto(
    args: RegisterDeviceDto,
  ): Promise<
    Array<Parameters<NotificationsServiceV2['upsertSubscriptions']>[0]>
  > {
    const safeV2Array: Array<
      Parameters<NotificationsServiceV2['upsertSubscriptions']>[0] & {
        upsertSubscriptionsDto: {
          safes: Array<UpsertSubscriptionsSafesDto>;
          signature: `0x${string}`;
        };
      }
    > = [];

    const safesV1Registrations = args.safeRegistrations;

    for (const safeV1Registration of safesV1Registrations) {
      if (safeV1Registration.safes.length) {
        const safeV2: Parameters<
          NotificationsServiceV2['upsertSubscriptions']
        >[0] & {
          upsertSubscriptionsDto: {
            safes: Array<UpsertSubscriptionsSafesDto>;
            signature: `0x${string}`;
          };
        } = {
          upsertSubscriptionsDto: {
            cloudMessagingToken: args.cloudMessagingToken,
            deviceType: args.deviceType,
            deviceUuid: (args.uuid as UUID) || undefined,
            safes: [],
            signature: safeV1Registration.signatures[0] as `0x${string}`,
          },
          authPayload: new AuthPayload(),
        };
        const uniqueSafeAddresses = new Set(safeV1Registration.safes);
        for (const safeAddresses of uniqueSafeAddresses) {
          safeV2.upsertSubscriptionsDto.safes.push({
            address: safeAddresses as `0x${string}`,
            chainId: safeV1Registration.chainId,
            notificationTypes: Object.values(NotificationType),
          });
        }
        safeV2Array.push(safeV2);
      }
    }

    for (const [index, safeV2] of safeV2Array.entries()) {
      const safeAddresses = args.safeRegistrations.flatMap(
        (safe) => safe.safes,
      );

      const recoveredAddress = await recoverMessageAddress({
        message: {
          raw: keccak256(
            toBytes(
              `gnosis-safe${args.timestamp}${args.uuid}${args.cloudMessagingToken}${safeAddresses.sort().join('')}`,
            ),
          ),
        },
        signature: safeV2.upsertSubscriptionsDto.signature,
      });

      safeV2.authPayload.chain_id =
        safeV2.upsertSubscriptionsDto.safes[0].chainId;
      safeV2.authPayload.signer_address = recoveredAddress;

      safeV2Array[index].authPayload = safeV2.authPayload;
    }

    return safeV2Array;
  }

  private validateTimestamp(timestamp: number): void {
    const currentDate = new Date();
    currentDate.setMinutes(currentDate.getMinutes() + 5);
    const currentTimestampInSeconds = Math.floor(currentDate.getTime() / 1000);

    const inputDate = new Date(timestamp * 1000);
    inputDate.setMinutes(inputDate.getMinutes() + 5);
    const inputTimestampInSeconds = Math.floor(inputDate.getTime() / 1000);

    if (
      currentTimestampInSeconds - inputTimestampInSeconds >
      NotificationsController.REGISTRATION_TIMESTAMP_EXPIRY
    ) {
      throw new BadRequestException('The signature is expired!');
    }
  }

  @Delete('chains/:chainId/notifications/devices/:uuid')
  async unregisterDevice(
    @Param('chainId') chainId: string,
    @Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
  ): Promise<void> {
    if (this.isPushNotificationV2Enabled) {
      return await this.unregisterDeviceV2Compatible(chainId, uuid);
    }

    await this.notificationsService.unregisterDevice({ chainId, uuid });
  }

  private async unregisterDeviceV2Compatible(
    chainId: string,
    uuid: UUID,
  ): Promise<void> {
    try {
      await this.notificationServiceV2.deleteDevice(uuid);
    } catch (error: unknown) {
      if (error instanceof NotFoundException) {
        // Do not throw a NotFound error when attempting to remove the token from the CGW,
        // This ensures the TX service remove method is called
      } else {
        throw error;
      }
    }

    try {
      await this.notificationsService.unregisterDevice({ chainId, uuid });
    } catch (error: unknown) {
      // The token might already have been removed from the TX service.
      // If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
      const errorObject = error as { code?: number };
      if (errorObject?.code !== 404) {
        throw error;
      }
    }
  }

  @Delete('chains/:chainId/notifications/devices/:uuid/safes/:safeAddress')
  async unregisterSafe(
    @Param('chainId') chainId: string,
    @Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
    @Param('safeAddress', new ValidationPipe(AddressSchema))
    safeAddress: `0x${string}`,
  ): Promise<void> {
    if (this.isPushNotificationV2Enabled) {
      return this.unregisterSafeV2Compatible(chainId, uuid, safeAddress);
    }

    await this.notificationsService.unregisterSafe({
      chainId,
      uuid,
      safeAddress,
    });
  }

  private async unregisterSafeV2Compatible(
    chainId: string,
    uuid: UUID,
    safeAddress: `0x${string}`,
  ): Promise<void> {
    try {
      // Compatibility with V2
      await this.notificationServiceV2.deleteSubscription({
        deviceUuid: uuid,
        chainId: chainId,
        safeAddress: safeAddress,
      });
    } catch (error: unknown) {
      if (error instanceof NotFoundException) {
        // Do not throw a NotFound error when attempting to remove the token from the CGW,
        // This ensures the TX service remove method is called
      } else {
        throw error;
      }
    }

    try {
      await this.notificationsService.unregisterSafe({
        chainId,
        uuid,
        safeAddress,
      });
    } catch (error: unknown) {
      // The token might already have been removed from the TX service.
      // If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
      const errorObject = error as { code?: number };
      if (errorObject?.code !== 404) {
        throw error;
      }
    }
  }
}

1	import {	110✔
2	BadRequestException,
3	Body,
4	Controller,
5	Delete,
6	HttpCode,
7	Inject,
8	NotFoundException,
9	Param,
10	Post,
11	} from '@nestjs/common';
12	import { ApiOkResponse, ApiTags } from '@nestjs/swagger';	110✔
13	import { RegisterDeviceDto } from '@/routes/notifications/v1/entities/register-device.dto.entity';	110✔
14	import { NotificationsService } from '@/routes/notifications/v1/notifications.service';	110✔
15	import { ValidationPipe } from '@/validation/pipes/validation.pipe';	110✔
16	import { AddressSchema } from '@/validation/entities/schemas/address.schema';	110✔
17	import type { UpsertSubscriptionsSafesDto } from '@/routes/notifications/v2/entities/upsert-subscriptions.dto.entity';
18	import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';	110✔
19	import { NotificationType } from '@/domain/notifications/v2/entities/notification.entity';	110✔
20	import type { UUID } from 'crypto';
21	import { NotificationsServiceV2 } from '@/routes/notifications/v2/notifications.service';	110✔
22	import { keccak256, recoverMessageAddress, toBytes } from 'viem';	110✔
23	import { UuidSchema } from '@/validation/entities/schemas/uuid.schema';	110✔
24	import { IConfigurationService } from '@/config/configuration.service.interface';	110✔
25	import {	110✔
26	LoggingService,
27	type ILoggingService,
28	} from '@/logging/logging.interface';
29
30	@ApiTags('notifications')
31	@Controller({ path: '', version: '1' })
32	export class NotificationsController {	110✔
33	private static REGISTRATION_TIMESTAMP_EXPIRY = 5 * 60;	110✔
34	private isPushNotificationV2Enabled: boolean;
35	constructor(
36	// Adding NotificationServiceV2 to ensure compatibility with V1.
37	// @TODO Remove NotificationModuleV2 after all clients have migrated and compatibility is no longer needed.
38	@Inject(NotificationsServiceV2)
39	private readonly notificationServiceV2: NotificationsServiceV2,	1,260✔
40	private readonly notificationsService: NotificationsService,	1,260✔
41
42	@Inject(IConfigurationService)
43	private readonly configurationService: IConfigurationService,	1,260✔
44
45	@Inject(LoggingService)
46	private readonly loggingService: ILoggingService,	1,260✔
47	) {
48	this.isPushNotificationV2Enabled =	1,260✔
49	this.configurationService.getOrThrow<boolean>(
50	'features.pushNotifications',
51	);
52	}
53
54	@ApiOkResponse()
55	@Post('register/notifications')
56	@HttpCode(200)
57	async registerDevice(	110✔
58	@Body() registerDeviceDto: RegisterDeviceDto,
59	): Promise<void> {
60	if (!this.isPushNotificationV2Enabled) {	24✔
61	return await this.notificationsService.registerDevice(registerDeviceDto);	12✔
62	}
63
64	if (registerDeviceDto.timestamp) {	12✔
65	this.validateTimestamp(parseInt(registerDeviceDto.timestamp));	12✔
66	}
67
68	// Compatibility with V2
69	const compatibleV2Requests =
70	await this.createV2RegisterDto(registerDeviceDto);	10✔
71
72	const v2Requests = [];	10✔
73
74	for (const compatibleV2Request of compatibleV2Requests) {	10✔
75	v2Requests.push(	60✔
76	await this.notificationServiceV2.upsertSubscriptions(
77	compatibleV2Request,
78	),
79	);
80	}
81	await Promise.all(v2Requests);	10✔
82
83	// Remove tokens from the old service to prevent duplication.
84	if (registerDeviceDto.uuid) {	10✔
85	const unregistrationRequests = [];	10✔
86	for (const safeRegistration of registerDeviceDto.safeRegistrations) {	10✔
87	unregistrationRequests.push(	74✔
88	this.notificationsService.unregisterDevice({
89	chainId: safeRegistration.chainId,
90	uuid: registerDeviceDto.uuid,
91	}),
92	);
93	}
94
95	await Promise.allSettled(unregistrationRequests).then(	10✔
96	(results: Array<PromiseSettledResult<unknown>>) => {
97	for (const result of results) {	10✔
98	// If the device is not already registered, the TX service will throw a 404 error, but we can safely ignore it.
99	if (	74✔
100	result.status === 'rejected' &&	53✔
101	'code' in result.reason &&
102	result.reason.code !== 404
103	) {
104	this.loggingService.error(result.reason);	8✔
105	}
106	}
107	},
108	);
109	}
110	}
111
112	private async createV2RegisterDto(
113	args: RegisterDeviceDto,
114	): Promise<
115	Array<Parameters<NotificationsServiceV2['upsertSubscriptions']>[0]>
116	> {
117	const safeV2Array: Array<
118	Parameters<NotificationsServiceV2['upsertSubscriptions']>[0] & {
119	upsertSubscriptionsDto: {
120	safes: Array<UpsertSubscriptionsSafesDto>;
121	signature: `0x${string}`;
122	};
123	}
124	> = [];	10✔
125
126	const safesV1Registrations = args.safeRegistrations;	10✔
127
128	for (const safeV1Registration of safesV1Registrations) {	10✔
129	if (safeV1Registration.safes.length) {	74✔
130	const safeV2: Parameters<
131	NotificationsServiceV2['upsertSubscriptions']
132	>[0] & {
133	upsertSubscriptionsDto: {
134	safes: Array<UpsertSubscriptionsSafesDto>;
135	signature: `0x${string}`;
136	};
137	} = {	60✔
138	upsertSubscriptionsDto: {
139	cloudMessagingToken: args.cloudMessagingToken,
140	deviceType: args.deviceType,
141	deviceUuid: (args.uuid as UUID) \|\| undefined,	30!
142	safes: [],
143	signature: safeV1Registration.signatures[0] as `0x${string}`,
144	},
145	authPayload: new AuthPayload(),
146	};
147	const uniqueSafeAddresses = new Set(safeV1Registration.safes);	60✔
148	for (const safeAddresses of uniqueSafeAddresses) {	60✔
149	safeV2.upsertSubscriptionsDto.safes.push({	184✔
150	address: safeAddresses as `0x${string}`,
151	chainId: safeV1Registration.chainId,
152	notificationTypes: Object.values(NotificationType),
153	});
154	}
155	safeV2Array.push(safeV2);	60✔
156	}
157	}
158
159	for (const [index, safeV2] of safeV2Array.entries()) {	10✔
160	const safeAddresses = args.safeRegistrations.flatMap(	60✔
161	(safe) => safe.safes,	790✔
162	);
163
164	const recoveredAddress = await recoverMessageAddress({	60✔
165	message: {
166	raw: keccak256(
167	toBytes(
168	`gnosis-safe${args.timestamp}${args.uuid}${args.cloudMessagingToken}${safeAddresses.sort().join('')}`,
169	),
170	),
171	},
172	signature: safeV2.upsertSubscriptionsDto.signature,
173	});
174
175	safeV2.authPayload.chain_id =	60✔
176	safeV2.upsertSubscriptionsDto.safes[0].chainId;
177	safeV2.authPayload.signer_address = recoveredAddress;	60✔
178
179	safeV2Array[index].authPayload = safeV2.authPayload;	60✔
180	}
181
182	return safeV2Array;	10✔
183	}
184
185	private validateTimestamp(timestamp: number): void {
186	const currentDate = new Date();	12✔
187	currentDate.setMinutes(currentDate.getMinutes() + 5);	12✔
188	const currentTimestampInSeconds = Math.floor(currentDate.getTime() / 1000);	12✔
189
190	const inputDate = new Date(timestamp * 1000);	12✔
191	inputDate.setMinutes(inputDate.getMinutes() + 5);	12✔
192	const inputTimestampInSeconds = Math.floor(inputDate.getTime() / 1000);	12✔
193
194	if (	12✔
195	currentTimestampInSeconds - inputTimestampInSeconds >
196	NotificationsController.REGISTRATION_TIMESTAMP_EXPIRY
197	) {
198	throw new BadRequestException('The signature is expired!');	2✔
199	}
200	}
201
202	@Delete('chains/:chainId/notifications/devices/:uuid')
203	async unregisterDevice(	110✔
204	@Param('chainId') chainId: string,
205	@Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
206	): Promise<void> {
207	if (this.isPushNotificationV2Enabled) {	22✔
208	return await this.unregisterDeviceV2Compatible(chainId, uuid);	16✔
209	}
210
211	await this.notificationsService.unregisterDevice({ chainId, uuid });	6✔
212	}
213
214	private async unregisterDeviceV2Compatible(
215	chainId: string,
216	uuid: UUID,
217	): Promise<void> {
218	try {	16✔
219	await this.notificationServiceV2.deleteDevice(uuid);	16✔
220	} catch (error: unknown) {
221	if (error instanceof NotFoundException) {	8✔
222	// Do not throw a NotFound error when attempting to remove the token from the CGW,
223	// This ensures the TX service remove method is called
224	} else {
225	throw error;	4✔
226	}
227	}
228
229	try {	12✔
230	await this.notificationsService.unregisterDevice({ chainId, uuid });	12✔
231	} catch (error: unknown) {
232	// The token might already have been removed from the TX service.
233	// If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
234	const errorObject = error as { code?: number };	6✔
235	if (errorObject?.code !== 404) {	6!
236	throw error;	4✔
237	}
238	}
239	}
240
241	@Delete('chains/:chainId/notifications/devices/:uuid/safes/:safeAddress')
242	async unregisterSafe(	110✔
243	@Param('chainId') chainId: string,
244	@Param('uuid', new ValidationPipe(UuidSchema)) uuid: UUID,
245	@Param('safeAddress', new ValidationPipe(AddressSchema))
246	safeAddress: `0x${string}`,
247	): Promise<void> {
248	if (this.isPushNotificationV2Enabled) {	14✔
249	return this.unregisterSafeV2Compatible(chainId, uuid, safeAddress);	8✔
250	}
251
252	await this.notificationsService.unregisterSafe({	6✔
253	chainId,
254	uuid,
255	safeAddress,
256	});
257	}
258
259	private async unregisterSafeV2Compatible(
260	chainId: string,
261	uuid: UUID,
262	safeAddress: `0x${string}`,
263	): Promise<void> {
264	try {	8✔
265	// Compatibility with V2
266	await this.notificationServiceV2.deleteSubscription({	8✔
267	deviceUuid: uuid,
268	chainId: chainId,
269	safeAddress: safeAddress,
270	});
271	} catch (error: unknown) {
UNCOV 272	if (error instanceof NotFoundException) {	×
273	// Do not throw a NotFound error when attempting to remove the token from the CGW,
274	// This ensures the TX service remove method is called
275	} else {
UNCOV 276	throw error;	×
277	}
278	}
279
280	try {	8✔
281	await this.notificationsService.unregisterSafe({	8✔
282	chainId,
283	uuid,
284	safeAddress,
285	});
286	} catch (error: unknown) {
287	// The token might already have been removed from the TX service.
288	// If this happens, the TX service will throw a 404 error, but it is safe to ignore it.
289	const errorObject = error as { code?: number };	6✔
290	if (errorObject?.code !== 404) {	6!
291	throw error;	4✔
292	}
293	}
294	}
295	}

safe-global / safe-client-gateway / 12297570138

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous