8882169363

Committed 29 Apr 2024 04:35PM UTC coverage: 92.274% (-0.02%) from 92.291%

Build # 8882169363

Build Type

Pull #1468

github

Committed by

iamacook

Commit Message

Merge branch 'get-email-jwt' into save-email-jwt

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

Run Details

1904 of 2326 branches covered (81.86%)

Branch coverage included in aggregate %.

16 of 18 new or added lines in 6 files covered. (88.89%)

1 existing line in 1 file now uncovered.

6874 of 7187 relevant lines covered (95.64%)

313.58 hits per line

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

88.51

/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 { ISafeRepository } from '@/domain/safe/safe.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(ISafeRepository) private readonly safeRepository: ISafeRepository,
  ) {
    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;
  }): Promise<Account> {
    const safeAddress = getAddress(args.safeAddress);
    const signer = getAddress(args.signer);

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

    if (
      !args.authPayload.isForChain(args.chainId) ||
      !args.authPayload.isForSigner(signer)
    ) {
      throw new UnauthorizedException();
    }

    // Check after AuthPayload check to avoid unnecessary request
    const isOwner = await this.safeRepository
      .isOwner({
        safeAddress,
        chainId: args.chainId,
        address: signer,
      })
      // Swallow error to avoid leaking information
      .catch(() => false);
    if (!isOwner) {
      throw new UnauthorizedException();
    }

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

safe-global / safe-client-gateway / 8882169363

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