8848987140

Committed 26 Apr 2024 01:21PM UTC coverage: 91.937% (+0.02%) from 91.916%

Build # 8848987140

Build Type

Pull #1468

github

Committed by

iamacook

Commit Message

Use schema

Pull Request Pull Request #1468: Authorise saving emails relative to JWT authentication

Run Details

1909 of 2341 branches covered (81.55%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 3 files covered. (100.0%)

9 existing lines in 1 file now uncovered.

6882 of 7221 relevant lines covered (95.31%)

313.27 hits per line

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

90.98

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

import { IAccountDataSource } from '@/domain/interfaces/account.datasource.interface';
import { Inject, Injectable } 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 { IAuthorizationRepository } from '@/domain/auth/authorization.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(IAuthorizationRepository)
    private readonly authorizationRepository: IAuthorizationRepository,
  ) {
    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);

    this.authorizationRepository.assertChainAndSigner({
      chainId: args.chainId,
      signerAddress: signer,
      authPayload: args.authPayload,
    });

    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: `0x${string}`;
    authPayload: AuthPayload | undefined;
  }): Promise<void> {
    const email = new EmailAddress(args.emailAddress);
    const verificationCode = this._generateCode();
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);

    this.authorizationRepository.assertChainAndSigner({
      chainId: args.chainId,
      signerAddress: signer,
      authPayload: args.authPayload,
    });

    await this.authorizationRepository.assertSafeOwner({
      safeAddress,
      authPayload: args.authPayload,
    });

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

safe-global / safe-client-gateway / 8848987140

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