8877268190

Committed 29 Apr 2024 10:44AM UTC coverage: 91.854% (-0.03%) from 91.887%

Build # 8877268190

Build Type

Pull #1460

github

Committed by

iamacook

Commit Message

Address comments

Pull Request Pull Request #1460: Authorise email retrieval relative to JWT authentication

Run Details

1917 of 2354 branches covered (81.44%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 4 files covered. (100.0%)

9 existing lines in 1 file now uncovered.

6890 of 7234 relevant lines covered (95.24%)

310.24 hits per line

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

90.44

/src/domain/account/account.repository.ts

import { IAccountDataSource } from '@/domain/interfaces/account.datasource.interface';
import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
import codeGenerator from '@/domain/account/code-generator';
import {
  Account,
  EmailAddress,
  VerificationCode,
} from '@/domain/account/entities/account.entity';
import { IAccountRepository } from '@/domain/account/account.repository.interface';
import { AccountSaveError } from '@/domain/account/errors/account-save.error';
import { ResendVerificationTimespanError } from '@/domain/account/errors/verification-timeframe.error';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { EmailAlreadyVerifiedError } from '@/domain/account/errors/email-already-verified.error';
import { InvalidVerificationCodeError } from '@/domain/account/errors/invalid-verification-code.error';
import { EmailEditMatchesError } from '@/domain/account/errors/email-edit-matches.error';
import { IEmailApi } from '@/domain/interfaces/email-api.interface';
import * as crypto from 'crypto';
import { ISubscriptionRepository } from '@/domain/subscriptions/subscription.repository.interface';
import { SubscriptionRepository } from '@/domain/subscriptions/subscription.repository';
import { AccountDoesNotExistError } from '@/domain/account/errors/account-does-not-exist.error';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { VerificationCodeDoesNotExistError } from '@/datasources/account/errors/verification-code-does-not-exist.error';
import { getAddress } from 'viem';
import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
import { IAuthRepository } from '@/domain/auth/auth.repository.interface';

@Injectable()
export class AccountRepository implements IAccountRepository {
  private readonly verificationCodeResendLockWindowMs: number;
  private readonly verificationCodeTtlMs: number;
  private static readonly VERIFICATION_CODE_EMAIL_SUBJECT = 'Verification code';

  constructor(
    @Inject(IAccountDataSource)
    private readonly accountDataSource: IAccountDataSource,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IEmailApi) private readonly emailApi: IEmailApi,
    @Inject(ISubscriptionRepository)
    private readonly subscriptionRepository: ISubscriptionRepository,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IAuthRepository)
    private readonly authRepository: IAuthRepository,
  ) {
    this.verificationCodeResendLockWindowMs =
      this.configurationService.getOrThrow(
        'email.verificationCode.resendLockWindowMs',
      );
    this.verificationCodeTtlMs = this.configurationService.getOrThrow(
      'email.verificationCode.ttlMs',
    );
  }

  private _generateCode(): string {
    const verificationCode = codeGenerator();
    // Pads the final verification code to 6 characters
    // The generated code might have less than 6 digits so the version to be
    // validated against should account with the leading zeroes
    return verificationCode.toString().padStart(6, '0');
  }

  async getAccount(args: {
    chainId: string;
    safeAddress: string;
    signer: `0x${string}`;
    authPayload: AuthPayload | undefined;
  }): Promise<Account> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);

    const isChain = this.authRepository.isChain({
      chainId: args.chainId,
      authPayload: args.authPayload,
    });
    const isSigner = this.authRepository.isSigner({
      signerAddress: signer,
      authPayload: args.authPayload,
    });

    if (!isChain || !isSigner) {
      throw new UnauthorizedException();
    }

    return this.accountDataSource.getAccount({
      chainId: args.chainId,
      safeAddress,
      signer,
    });
  }

  getAccounts(args: {
    chainId: string;
    safeAddress: string;
    onlyVerified: boolean;
  }): Promise<Account[]> {
    const safeAddress = getAddress(args.safeAddress);
    return this.accountDataSource.getAccounts({
      chainId: args.chainId,
      safeAddress,
      onlyVerified: args.onlyVerified,
    });
  }

  async createAccount(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    signer: string;
  }): Promise<void> {
    const email = new EmailAddress(args.emailAddress);
    const verificationCode = this._generateCode();
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);

    try {
      await this.accountDataSource.createAccount({
        chainId: args.chainId,
        code: verificationCode,
        emailAddress: email,
        safeAddress,
        signer,
        codeGenerationDate: new Date(),
        unsubscriptionToken: crypto.randomUUID(),
      });
      // New account registrations should be subscribed to the Account Recovery category
      await this.subscriptionRepository.subscribe({
        chainId: args.chainId,
        signer,
        safeAddress,
        notificationTypeKey: SubscriptionRepository.CATEGORY_ACCOUNT_RECOVERY,
      });
      this._sendEmailVerification({
        ...args,
        signer,
        safeAddress,
        code: verificationCode,
      });
    } catch (e) {
      throw new AccountSaveError(args.chainId, args.safeAddress, args.signer);
    }
  }

  async resendEmailVerification(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }): Promise<void> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);
    const account = await this.accountDataSource.getAccount({
      chainId: args.chainId,
      safeAddress,
      signer,
    });

    // If the account was already verified, we should not send out a new
    // verification code
    if (account.isVerified) {
      throw new EmailAlreadyVerifiedError(args);
    }

    const verificationCode: VerificationCode | null =
      await this.accountDataSource
        .getAccountVerificationCode({
          chainId: args.chainId,
          safeAddress,
          signer,
        })
        .catch((reason) => {
          this.loggingService.warn(reason);
          return null;
        });

    // If there's a date for when the verification was sent out,
    // check if timespan is still valid.
    if (verificationCode?.sentOn) {
      const timespanMs = Date.now() - verificationCode.sentOn.getTime();
      if (timespanMs < this.verificationCodeResendLockWindowMs) {
        throw new ResendVerificationTimespanError({
          ...args,
          timespanMs,
          lockWindowMs: this.verificationCodeResendLockWindowMs,
        });
      }
    }

    if (!this._isEmailVerificationCodeValid(verificationCode)) {
      // Expired or non-existent code. Generate new one
      await this.accountDataSource.setEmailVerificationCode({
        chainId: args.chainId,
        safeAddress,
        signer,
        code: this._generateCode(),
        codeGenerationDate: new Date(),
      });
    }

    const currentVerificationCode =
      await this.accountDataSource.getAccountVerificationCode({
        chainId: args.chainId,
        safeAddress,
        signer,
      });

    this._sendEmailVerification({
      chainId: args.chainId,
      safeAddress,
      signer,
      code: currentVerificationCode.code,
      emailAddress: account.emailAddress.value,
    });
  }

  async verifyEmailAddress(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
    code: string;
  }): Promise<void> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);
    const account = await this.accountDataSource.getAccount({
      chainId: args.chainId,
      safeAddress,
      signer,
    });

    if (account.isVerified) {
      // account is already verified, so we don't need to perform further checks
      throw new EmailAlreadyVerifiedError(args);
    }

    let verificationCode: VerificationCode;
    try {
      verificationCode =
        await this.accountDataSource.getAccountVerificationCode({
          chainId: args.chainId,
          safeAddress,
          signer,
        });
    } catch (e) {
      // If we attempt to verify an email is done without a verification code in place,
      // Send a new code to the client's email address for verification
      this.loggingService.warn(e);
      if (e instanceof VerificationCodeDoesNotExistError) {
        await this.resendEmailVerification(args);
      }
      // throw an error to the clients informing that the email address needs to be verified with a new code
      throw new Error('Email needs to be verified again');
    }

    if (verificationCode.code !== args.code) {
      throw new InvalidVerificationCodeError(args);
    }

    if (!this._isEmailVerificationCodeValid(verificationCode)) {
      throw new InvalidVerificationCodeError(args);
    }

    // TODO: it is possible that when verifying the email address, a new code generation was triggered
    await this.accountDataSource.verifyEmail({
      chainId: args.chainId,
      safeAddress,
      signer,
    });
  }

  async deleteAccount(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }): Promise<void> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);
    try {
      const account = await this.accountDataSource.getAccount({
        chainId: args.chainId,
        safeAddress,
        signer,
      });
      // If there is an error deleting the email address,
      // do not delete the respective account as we still need to get the email
      // for future deletions requests
      await this.emailApi.deleteEmailAddress({
        emailAddress: account.emailAddress.value,
      });
      await this.accountDataSource.deleteAccount({
        chainId: args.chainId,
        safeAddress,
        signer,
      });
    } catch (error) {
      this.loggingService.warn(error);
      // If there is no account, do not throw in order not to signal its existence
      if (!(error instanceof AccountDoesNotExistError)) {
        throw error;
      }
    }
  }

  async editEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    signer: string;
  }): Promise<void> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);
    const account = await this.accountDataSource.getAccount({
      chainId: args.chainId,
      safeAddress,
      signer,
    });
    const newEmail = new EmailAddress(args.emailAddress);

    if (newEmail.value === account.emailAddress.value) {
      throw new EmailEditMatchesError(args);
    }

    const newVerificationCode = this._generateCode();

    await this.accountDataSource.updateAccountEmail({
      chainId: args.chainId,
      emailAddress: newEmail,
      safeAddress,
      signer,
      unsubscriptionToken: crypto.randomUUID(),
    });
    await this.accountDataSource.setEmailVerificationCode({
      chainId: args.chainId,
      code: newVerificationCode,
      signer,
      codeGenerationDate: new Date(),
      safeAddress,
    });
    this._sendEmailVerification({
      chainId: args.chainId,
      safeAddress,
      signer,
      emailAddress: args.emailAddress,
      code: newVerificationCode,
    });
  }

  private _isEmailVerificationCodeValid(
    verificationCode: VerificationCode | null,
  ): boolean {
    if (!verificationCode || !verificationCode.generatedOn) return false;
    const window = Date.now() - verificationCode.generatedOn.getTime();
    return window < this.verificationCodeTtlMs;
  }

  /**
   * Sends the verification email to the target {@link args.emailAddress}
   *
   * This function returns "immediately" so the result of this operation won't
   * be known to the caller.
   *
   * @private
   */
  private _sendEmailVerification(args: {
    signer: `0x${string}`;
    chainId: string;
    code: string;
    emailAddress: string;
    safeAddress: `0x${string}`;
  }): void {
    this.emailApi
      .createMessage({
        to: [args.emailAddress],
        template: this.configurationService.getOrThrow(
          'email.templates.verificationCode',
        ),
        subject: AccountRepository.VERIFICATION_CODE_EMAIL_SUBJECT,
        substitutions: { verificationCode: args.code },
      })
      .catch(() => {
        this.loggingService.warn(`Error sending verification email.`);
      })
      .then(() =>
        // Update verification-sent date on a successful response
        this.accountDataSource.setEmailVerificationSentDate({
          chainId: args.chainId,
          safeAddress: args.safeAddress,
          signer: args.signer,
          sentOn: new Date(),
        }),
      )
      .catch(() =>
        this.loggingService.warn(
          'Error updating email verification sent date.',
        ),
      );
  }
}

1	import { IAccountDataSource } from '@/domain/interfaces/account.datasource.interface';	94✔
2	import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';	94✔
3	import codeGenerator from '@/domain/account/code-generator';	94✔
4	import {	94✔
5	Account,
6	EmailAddress,
7	VerificationCode,
8	} from '@/domain/account/entities/account.entity';
9	import { IAccountRepository } from '@/domain/account/account.repository.interface';
10	import { AccountSaveError } from '@/domain/account/errors/account-save.error';	94✔
11	import { ResendVerificationTimespanError } from '@/domain/account/errors/verification-timeframe.error';	94✔
12	import { IConfigurationService } from '@/config/configuration.service.interface';	94✔
13	import { EmailAlreadyVerifiedError } from '@/domain/account/errors/email-already-verified.error';	94✔
14	import { InvalidVerificationCodeError } from '@/domain/account/errors/invalid-verification-code.error';	94✔
15	import { EmailEditMatchesError } from '@/domain/account/errors/email-edit-matches.error';	94✔
16	import { IEmailApi } from '@/domain/interfaces/email-api.interface';	94✔
17	import * as crypto from 'crypto';	94✔
18	import { ISubscriptionRepository } from '@/domain/subscriptions/subscription.repository.interface';	94✔
19	import { SubscriptionRepository } from '@/domain/subscriptions/subscription.repository';	94✔
20	import { AccountDoesNotExistError } from '@/domain/account/errors/account-does-not-exist.error';	94✔
21	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	94✔
22	import { VerificationCodeDoesNotExistError } from '@/datasources/account/errors/verification-code-does-not-exist.error';	94✔
23	import { getAddress } from 'viem';	94✔
24	import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
25	import { IAuthRepository } from '@/domain/auth/auth.repository.interface';	94✔
26
27	@Injectable()
28	export class AccountRepository implements IAccountRepository {	94✔
29	private readonly verificationCodeResendLockWindowMs: number;
30	private readonly verificationCodeTtlMs: number;
31	private static readonly VERIFICATION_CODE_EMAIL_SUBJECT = 'Verification code';	94✔
32
33	constructor(
34	@Inject(IAccountDataSource)
35	private readonly accountDataSource: IAccountDataSource,	160✔
36	@Inject(IConfigurationService)
37	private readonly configurationService: IConfigurationService,	160✔
38	@Inject(IEmailApi) private readonly emailApi: IEmailApi,	160✔
39	@Inject(ISubscriptionRepository)
40	private readonly subscriptionRepository: ISubscriptionRepository,	160✔
41	@Inject(LoggingService) private readonly loggingService: ILoggingService,	160✔
42	@Inject(IAuthRepository)
43	private readonly authRepository: IAuthRepository,	160✔
44	) {
45	this.verificationCodeResendLockWindowMs =	160✔
46	this.configurationService.getOrThrow(
47	'email.verificationCode.resendLockWindowMs',
48	);
49	this.verificationCodeTtlMs = this.configurationService.getOrThrow(	160✔
50	'email.verificationCode.ttlMs',
51	);
52	}
53
54	private _generateCode(): string {
55	const verificationCode = codeGenerator();	12✔
56	// Pads the final verification code to 6 characters
57	// The generated code might have less than 6 digits so the version to be
58	// validated against should account with the leading zeroes
59	return verificationCode.toString().padStart(6, '0');	12✔
60	}
61
62	async getAccount(args: {
63	chainId: string;
64	safeAddress: string;
65	signer: `0x${string}`;
66	authPayload: AuthPayload \| undefined;
67	}): Promise<Account> {
68	const safeAddress = getAddress(args.safeAddress);	16✔
69	const signer = getAddress(args.signer);	16✔
70
71	const isChain = this.authRepository.isChain({	16✔
72	chainId: args.chainId,
73	authPayload: args.authPayload,
74	});
75	const isSigner = this.authRepository.isSigner({	16✔
76	signerAddress: signer,
77	authPayload: args.authPayload,
78	});
79
80	if (!isChain \|\| !isSigner) {	16✔
81	throw new UnauthorizedException();	10✔
82	}
83
84	return this.accountDataSource.getAccount({	6✔
85	chainId: args.chainId,
86	safeAddress,
87	signer,
88	});
89	}
90
91	getAccounts(args: {
92	chainId: string;
93	safeAddress: string;
94	onlyVerified: boolean;
95	}): Promise<Account[]> {
96	const safeAddress = getAddress(args.safeAddress);	32✔
97	return this.accountDataSource.getAccounts({	32✔
98	chainId: args.chainId,
99	safeAddress,
100	onlyVerified: args.onlyVerified,
101	});
102	}
103
104	async createAccount(args: {
105	chainId: string;
106	safeAddress: string;
107	emailAddress: string;
108	signer: string;
109	}): Promise<void> {
110	const email = new EmailAddress(args.emailAddress);	4✔
111	const verificationCode = this._generateCode();	4✔
112	const safeAddress = getAddress(args.safeAddress);	4✔
113	const signer = getAddress(args.signer);	4✔
114
115	try {	4✔
116	await this.accountDataSource.createAccount({	4✔
117	chainId: args.chainId,
118	code: verificationCode,
119	emailAddress: email,
120	safeAddress,
121	signer,
122	codeGenerationDate: new Date(),
123	unsubscriptionToken: crypto.randomUUID(),
124	});
125	// New account registrations should be subscribed to the Account Recovery category
126	await this.subscriptionRepository.subscribe({	4✔
127	chainId: args.chainId,
128	signer,
129	safeAddress,
130	notificationTypeKey: SubscriptionRepository.CATEGORY_ACCOUNT_RECOVERY,
131	});
132	this._sendEmailVerification({	4✔
133	...args,
134	signer,
135	safeAddress,
136	code: verificationCode,
137	});
138	} catch (e) {
UNCOV 139	throw new AccountSaveError(args.chainId, args.safeAddress, args.signer);	×
140	}
141	}
142
143	async resendEmailVerification(args: {
144	chainId: string;
145	safeAddress: string;
146	signer: string;
147	}): Promise<void> {
148	const safeAddress = getAddress(args.safeAddress);	10✔
149	const signer = getAddress(args.signer);	10✔
150	const account = await this.accountDataSource.getAccount({	10✔
151	chainId: args.chainId,
152	safeAddress,
153	signer,
154	});
155
156	// If the account was already verified, we should not send out a new
157	// verification code
158	if (account.isVerified) {	10✔
159	throw new EmailAlreadyVerifiedError(args);	2✔
160	}
161
162	const verificationCode: VerificationCode \| null =
163	await this.accountDataSource	8✔
164	.getAccountVerificationCode({
165	chainId: args.chainId,
166	safeAddress,
167	signer,
168	})
169	.catch((reason) => {
UNCOV 170	this.loggingService.warn(reason);	×
UNCOV 171	return null;	×
172	});
173
174	// If there's a date for when the verification was sent out,
175	// check if timespan is still valid.
176	if (verificationCode?.sentOn) {	8!
177	const timespanMs = Date.now() - verificationCode.sentOn.getTime();	8✔
178	if (timespanMs < this.verificationCodeResendLockWindowMs) {	8✔
179	throw new ResendVerificationTimespanError({	2✔
180	...args,
181	timespanMs,
182	lockWindowMs: this.verificationCodeResendLockWindowMs,
183	});
184	}
185	}
186
187	if (!this._isEmailVerificationCodeValid(verificationCode)) {	6✔
188	// Expired or non-existent code. Generate new one
189	await this.accountDataSource.setEmailVerificationCode({	2✔
190	chainId: args.chainId,
191	safeAddress,
192	signer,
193	code: this._generateCode(),
194	codeGenerationDate: new Date(),
195	});
196	}
197
198	const currentVerificationCode =
199	await this.accountDataSource.getAccountVerificationCode({	6✔
200	chainId: args.chainId,
201	safeAddress,
202	signer,
203	});
204
205	this._sendEmailVerification({	6✔
206	chainId: args.chainId,
207	safeAddress,
208	signer,
209	code: currentVerificationCode.code,
210	emailAddress: account.emailAddress.value,
211	});
212	}
213
214	async verifyEmailAddress(args: {
215	chainId: string;
216	safeAddress: string;
217	signer: string;
218	code: string;
219	}): Promise<void> {
220	const safeAddress = getAddress(args.safeAddress);	8✔
221	const signer = getAddress(args.signer);	8✔
222	const account = await this.accountDataSource.getAccount({	8✔
223	chainId: args.chainId,
224	safeAddress,
225	signer,
226	});
227
228	if (account.isVerified) {	8✔
229	// account is already verified, so we don't need to perform further checks
230	throw new EmailAlreadyVerifiedError(args);	2✔
231	}
232
233	let verificationCode: VerificationCode;
234	try {	6✔
235	verificationCode =	6✔
236	await this.accountDataSource.getAccountVerificationCode({
237	chainId: args.chainId,
238	safeAddress,
239	signer,
240	});
241	} catch (e) {
242	// If we attempt to verify an email is done without a verification code in place,
243	// Send a new code to the client's email address for verification
UNCOV 244	this.loggingService.warn(e);	×
UNCOV 245	if (e instanceof VerificationCodeDoesNotExistError) {	×
UNCOV 246	await this.resendEmailVerification(args);	×
247	}
248	// throw an error to the clients informing that the email address needs to be verified with a new code
UNCOV 249	throw new Error('Email needs to be verified again');	×
250	}
251
252	if (verificationCode.code !== args.code) {	6✔
253	throw new InvalidVerificationCodeError(args);	2✔
254	}
255
256	if (!this._isEmailVerificationCodeValid(verificationCode)) {	4✔
257	throw new InvalidVerificationCodeError(args);	2✔
258	}
259
260	// TODO: it is possible that when verifying the email address, a new code generation was triggered
261	await this.accountDataSource.verifyEmail({	2✔
262	chainId: args.chainId,
263	safeAddress,
264	signer,
265	});
266	}
267
268	async deleteAccount(args: {
269	chainId: string;
270	safeAddress: string;
271	signer: string;
272	}): Promise<void> {
273	const safeAddress = getAddress(args.safeAddress);	10✔
274	const signer = getAddress(args.signer);	8✔
275	try {	8✔
276	const account = await this.accountDataSource.getAccount({	8✔
277	chainId: args.chainId,
278	safeAddress,
279	signer,
280	});
281	// If there is an error deleting the email address,
282	// do not delete the respective account as we still need to get the email
283	// for future deletions requests
284	await this.emailApi.deleteEmailAddress({	6✔
285	emailAddress: account.emailAddress.value,
286	});
287	await this.accountDataSource.deleteAccount({	4✔
288	chainId: args.chainId,
289	safeAddress,
290	signer,
291	});
292	} catch (error) {
293	this.loggingService.warn(error);	4✔
294	// If there is no account, do not throw in order not to signal its existence
295	if (!(error instanceof AccountDoesNotExistError)) {	4✔
296	throw error;	2✔
297	}
298	}
299	}
300
301	async editEmail(args: {
302	chainId: string;
303	safeAddress: string;
304	emailAddress: string;
305	signer: string;
306	}): Promise<void> {
307	const safeAddress = getAddress(args.safeAddress);	12✔
308	const signer = getAddress(args.signer);	10✔
309	const account = await this.accountDataSource.getAccount({	10✔
310	chainId: args.chainId,
311	safeAddress,
312	signer,
313	});
314	const newEmail = new EmailAddress(args.emailAddress);	8✔
315
316	if (newEmail.value === account.emailAddress.value) {	8✔
317	throw new EmailEditMatchesError(args);	2✔
318	}
319
320	const newVerificationCode = this._generateCode();	6✔
321
322	await this.accountDataSource.updateAccountEmail({	6✔
323	chainId: args.chainId,
324	emailAddress: newEmail,
325	safeAddress,
326	signer,
327	unsubscriptionToken: crypto.randomUUID(),
328	});
329	await this.accountDataSource.setEmailVerificationCode({	4✔
330	chainId: args.chainId,
331	code: newVerificationCode,
332	signer,
333	codeGenerationDate: new Date(),
334	safeAddress,
335	});
336	this._sendEmailVerification({	4✔
337	chainId: args.chainId,
338	safeAddress,
339	signer,
340	emailAddress: args.emailAddress,
341	code: newVerificationCode,
342	});
343	}
344
345	private _isEmailVerificationCodeValid(
346	verificationCode: VerificationCode \| null,
347	): boolean {
348	if (!verificationCode \|\| !verificationCode.generatedOn) return false;	10!
349	const window = Date.now() - verificationCode.generatedOn.getTime();	10✔
350	return window < this.verificationCodeTtlMs;	10✔
351	}
352
353	/**
354	* Sends the verification email to the target {@link args.emailAddress}
355	*
356	* This function returns "immediately" so the result of this operation won't
357	* be known to the caller.
358	*
359	* @private
360	*/
361	private _sendEmailVerification(args: {
362	signer: `0x${string}`;
363	chainId: string;
364	code: string;
365	emailAddress: string;
366	safeAddress: `0x${string}`;
367	}): void {
368	this.emailApi	14✔
369	.createMessage({
370	to: [args.emailAddress],
371	template: this.configurationService.getOrThrow(
372	'email.templates.verificationCode',
373	),
374	subject: AccountRepository.VERIFICATION_CODE_EMAIL_SUBJECT,
375	substitutions: { verificationCode: args.code },
376	})
377	.catch(() => {
UNCOV 378	this.loggingService.warn(`Error sending verification email.`);	×
379	})
380	.then(() =>
381	// Update verification-sent date on a successful response
382	this.accountDataSource.setEmailVerificationSentDate({	14✔
383	chainId: args.chainId,
384	safeAddress: args.safeAddress,
385	signer: args.signer,
386	sentOn: new Date(),
387	}),
388	)
389	.catch(() =>
UNCOV 390	this.loggingService.warn(	×
391	'Error updating email verification sent date.',
392	),
393	);
394	}
395	}

safe-global / safe-client-gateway / 8877268190

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