7044813912

Committed 30 Nov 2023 09:58AM UTC coverage: 89.768% (+0.08%) from 89.689%

Build # 7044813912

Build Type

Pull #872

github

Committed by

hectorgomezv

Commit Message

Check EMAIL_TEMPLATE_UNKNOWN_RECOVERY_TX is set in environment

Pull Request Pull Request #872: Send unknown recovery transaction email

Run Details

1411 of 1708 branches covered (0.0%)

Branch coverage included in aggregate %.

14 of 20 new or added lines in 5 files covered. (70.0%)

3 existing lines in 1 file now uncovered.

5248 of 5710 relevant lines covered (91.91%)

150.98 hits per line

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

40.82

/src/domain/alerts/alerts.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import { Hex } from 'viem';
import { IAlertsRepository } from '@/domain/alerts/alerts.repository.interface';
import { IAlertsApi } from '@/domain/interfaces/alerts-api.interface';
import { AlertsRegistration } from '@/domain/alerts/entities/alerts.entity';
import { AlertLog } from '@/routes/alerts/entities/alert.dto.entity';
import { DelayModifierDecoder } from '@/domain/alerts/contracts/delay-modifier-decoder.helper';
import { SafeDecoder } from '@/domain/alerts/contracts/safe-decoder.helper';
import { MultiSendDecoder } from '@/domain/alerts/contracts/multi-send-decoder.helper';
import { IEmailApi } from '@/domain/interfaces/email-api.interface';
import { IEmailRepository } from '@/domain/email/email.repository.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { IConfigurationService } from '@/config/configuration.service.interface';

@Injectable()
export class AlertsRepository implements IAlertsRepository {
  constructor(
    @Inject(IAlertsApi)
    private readonly alertsApi: IAlertsApi,
    @Inject(IEmailApi)
    private readonly emailApi: IEmailApi,
    @Inject(IEmailRepository)
    private readonly emailRepository: IEmailRepository,
    private readonly delayModifierDecoder: DelayModifierDecoder,
    private readonly safeDecoder: SafeDecoder,
    private readonly multiSendDecoder: MultiSendDecoder,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {}

  async addContracts(contracts: Array<AlertsRegistration>): Promise<void> {
    await this.alertsApi.addContracts(contracts);
  }

  async handleAlertLog(chainId: string, log: AlertLog): Promise<void> {
    const decodedEvent = this.delayModifierDecoder.decodeEventLog({
      data: log.data as Hex,
      topics: log.topics as [Hex, Hex, Hex],
    });

    const decodedTransactions = this.decodeTransactionAdded(
      decodedEvent.args.data,
    );

    if (!decodedTransactions) {
      return this.notifyInvalidTransaction(chainId, log);
    }

    for (const decodedTransaction of decodedTransactions) {
      switch (decodedTransaction.functionName) {
        case 'addOwnerWithThreshold': {
          // const safeAddress = decodedEvent.args.to;
          // const [owner, _threshold] = decodedTransaction.args;
          break;
        }
        case 'removeOwner': {
          // const safeAddress = decodedEvent.args.to;
          // const [prevOwner, owner, _threshold] = decodedTransaction.args;
          break;
        }
        case 'swapOwner': {
          // const safeAddress = decodedEvent.args.to;
          // const [prevOwner, oldOwner, newOwner] = decodedTransaction.args;
          break;
        }
        case 'changeThreshold': {
          // const safeAddress = decodedEvent.args.to;
          // const [_threshold] = decodedTransaction.args;
          break;
        }
        default: {
          return this.notifyInvalidTransaction(chainId, log);
        }
      }
    }
  }

  private decodeTransactionAdded(data: Hex) {
    try {
      return this.multiSendDecoder
        .mapMultiSendTransactions(data)
        .map(this.safeDecoder.decodeFunctionData);
    } catch {
      try {
        return [this.safeDecoder.decodeFunctionData({ data })];
      } catch {
        return null;
      }
    }
  }

  private async notifyInvalidTransaction(
    chainId: string,
    log: AlertLog,
  ): Promise<void> {
    const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({
      chainId,
      safeAddress: log.address,
    });

    if (emails.length) {
      return this.emailApi.createMessage({
        to: emails,
        template: this.configurationService.getOrThrow<string>(
          'email.templates.unknownRecoveryTx',
        ),
        subject: 'Unknown transaction attempt',
        substitutions: {},
      });
    }
    this.loggingService.debug(
      `An alert log for an invalid transaction with no verified emails associated was thrown for Safe ${log.address}`,
    );
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	62✔
2	import { Hex } from 'viem';
3	import { IAlertsRepository } from '@/domain/alerts/alerts.repository.interface';
4	import { IAlertsApi } from '@/domain/interfaces/alerts-api.interface';	62✔
5	import { AlertsRegistration } from '@/domain/alerts/entities/alerts.entity';
6	import { AlertLog } from '@/routes/alerts/entities/alert.dto.entity';
7	import { DelayModifierDecoder } from '@/domain/alerts/contracts/delay-modifier-decoder.helper';	62✔
8	import { SafeDecoder } from '@/domain/alerts/contracts/safe-decoder.helper';	62✔
9	import { MultiSendDecoder } from '@/domain/alerts/contracts/multi-send-decoder.helper';	62✔
10	import { IEmailApi } from '@/domain/interfaces/email-api.interface';	62✔
11	import { IEmailRepository } from '@/domain/email/email.repository.interface';	62✔
12	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	62✔
13	import { IConfigurationService } from '@/config/configuration.service.interface';	62✔
14
15	@Injectable()
16	export class AlertsRepository implements IAlertsRepository {	62✔
17	constructor(
18	@Inject(IAlertsApi)
19	private readonly alertsApi: IAlertsApi,	490✔
20	@Inject(IEmailApi)
21	private readonly emailApi: IEmailApi,	490✔
22	@Inject(IEmailRepository)
23	private readonly emailRepository: IEmailRepository,	490✔
24	private readonly delayModifierDecoder: DelayModifierDecoder,	490✔
25	private readonly safeDecoder: SafeDecoder,	490✔
26	private readonly multiSendDecoder: MultiSendDecoder,	490✔
27	@Inject(LoggingService)
28	private readonly loggingService: ILoggingService,	490✔
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	490✔
31	) {}
32
33	async addContracts(contracts: Array<AlertsRegistration>): Promise<void> {
34	await this.alertsApi.addContracts(contracts);	6✔
35	}
36
37	async handleAlertLog(chainId: string, log: AlertLog): Promise<void> {
38	const decodedEvent = this.delayModifierDecoder.decodeEventLog({	10✔
39	data: log.data as Hex,
40	topics: log.topics as [Hex, Hex, Hex],
41	});
42
43	const decodedTransactions = this.decodeTransactionAdded(	×
44	decodedEvent.args.data,
45	);
46
47	if (!decodedTransactions) {	×
NEW 48	return this.notifyInvalidTransaction(chainId, log);	×
49	}
50
51	for (const decodedTransaction of decodedTransactions) {	×
52	switch (decodedTransaction.functionName) {	×
53	case 'addOwnerWithThreshold': {
54	// const safeAddress = decodedEvent.args.to;
55	// const [owner, _threshold] = decodedTransaction.args;
56	break;	×
57	}
58	case 'removeOwner': {
59	// const safeAddress = decodedEvent.args.to;
60	// const [prevOwner, owner, _threshold] = decodedTransaction.args;
61	break;	×
62	}
63	case 'swapOwner': {
64	// const safeAddress = decodedEvent.args.to;
65	// const [prevOwner, oldOwner, newOwner] = decodedTransaction.args;
66	break;	×
67	}
68	case 'changeThreshold': {
69	// const safeAddress = decodedEvent.args.to;
70	// const [_threshold] = decodedTransaction.args;
71	break;	×
72	}
73	default: {
NEW 74	return this.notifyInvalidTransaction(chainId, log);	×
75	}
76	}
77	}
78	}
79
80	private decodeTransactionAdded(data: Hex) {
81	try {	×
82	return this.multiSendDecoder	×
83	.mapMultiSendTransactions(data)
84	.map(this.safeDecoder.decodeFunctionData);
85	} catch {
86	try {	×
87	return [this.safeDecoder.decodeFunctionData({ data })];	×
88	} catch {
89	return null;	×
90	}
91	}
92	}
93
94	private async notifyInvalidTransaction(
95	chainId: string,
96	log: AlertLog,
97	): Promise<void> {
NEW 98	const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({	×
99	chainId,
100	safeAddress: log.address,
101	});
102
NEW 103	if (emails.length) {	×
NEW 104	return this.emailApi.createMessage({	×
105	to: emails,
106	template: this.configurationService.getOrThrow<string>(
107	'email.templates.unknownRecoveryTx',
108	),
109	subject: 'Unknown transaction attempt',
110	substitutions: {},
111	});
112	}
NEW 113	this.loggingService.debug(	×
114	`An alert log for an invalid transaction with no verified emails associated was thrown for Safe ${log.address}`,
115	);
116	}
117	}

safe-global / safe-client-gateway / 7044813912

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