8850025282

Committed 26 Apr 2024 02:39PM UTC coverage: 91.872% (+0.05%) from 91.824%

Build # 8850025282

Build Type

Pull #1460

github

Committed by

iamacook

Commit Message

Merge branch 'main' into get-email-jwt

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

Run Details

1924 of 2361 branches covered (81.49%)

Branch coverage included in aggregate %.

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

8 existing lines in 1 file now uncovered.

6892 of 7235 relevant lines covered (95.26%)

309.12 hits per line

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

90.84

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

safe-global / safe-client-gateway / 8850025282

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