8877703743

Committed 29 Apr 2024 11:21AM UTC coverage: 91.865% (+0.07%) from 91.796%

Build # 8877703743

Build Type

Pull #1469

github

Committed by

iamacook

Commit Message

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

Pull Request Pull Request #1469: Authorise email deletion relative to JWT authentication

Run Details

1913 of 2352 branches covered (81.34%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

6873 of 7212 relevant lines covered (95.3%)

315.21 hits per line

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

91.61

/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: `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);

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

    if (!isChain || !isSigner || !isSafeOwner) {
      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: `0x${string}`;
    authPayload: AuthPayload | undefined;
  }): Promise<void> {
    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();
    }

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

safe-global / safe-client-gateway / 8877703743

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