7061879100

Committed 01 Dec 2023 03:21PM UTC coverage: 90.106% (+0.4%) from 89.734%

Build # 7061879100

Build Type

Pull #895

github

Committed by

hectorgomezv

Commit Message

Add test for unknown recovery transaction

Pull Request Pull Request #895: Add test for unknown recovery transaction attempt

Run Details

1417 of 1709 branches covered (0.0%)

Branch coverage included in aggregate %.

43 of 45 new or added lines in 9 files covered. (95.56%)

8 existing lines in 3 files now uncovered.

5286 of 5730 relevant lines covered (92.25%)

151.7 hits per line

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

70.0

/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._notifyUnknownTransaction(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._notifyUnknownTransaction(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 _notifyUnknownTransaction(
    chainId: string,
    log: AlertLog,
  ): Promise<void> {
    const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({
      chainId,
      safeAddress: log.address,
    });

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

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,	492✔
20	@Inject(IEmailApi)
21	private readonly emailApi: IEmailApi,	492✔
22	@Inject(IEmailRepository)
23	private readonly emailRepository: IEmailRepository,	492✔
24	private readonly delayModifierDecoder: DelayModifierDecoder,	492✔
25	private readonly safeDecoder: SafeDecoder,	492✔
26	private readonly multiSendDecoder: MultiSendDecoder,	492✔
27	@Inject(LoggingService)
28	private readonly loggingService: ILoggingService,	492✔
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	492✔
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({	24✔
39	data: log.data as Hex,
40	topics: log.topics as [Hex, Hex, Hex],
41	});
42
43	const decodedTransactions = this.decodeTransactionAdded(	24✔
44	decodedEvent.args.data,
45	);
46
47	if (!decodedTransactions) {	4✔
48	return this._notifyUnknownTransaction(chainId, log);	4✔
49	}
50
UNCOV 51	for (const decodedTransaction of decodedTransactions) {	×
UNCOV 52	switch (decodedTransaction.functionName) {	×
53	case 'addOwnerWithThreshold': {
54	// const safeAddress = decodedEvent.args.to;
55	// const [owner, _threshold] = decodedTransaction.args;
UNCOV 56	break;	×
57	}
58	case 'removeOwner': {
59	// const safeAddress = decodedEvent.args.to;
60	// const [prevOwner, owner, _threshold] = decodedTransaction.args;
UNCOV 61	break;	×
62	}
63	case 'swapOwner': {
64	// const safeAddress = decodedEvent.args.to;
65	// const [prevOwner, oldOwner, newOwner] = decodedTransaction.args;
UNCOV 66	break;	×
67	}
68	case 'changeThreshold': {
69	// const safeAddress = decodedEvent.args.to;
70	// const [_threshold] = decodedTransaction.args;
UNCOV 71	break;	×
72	}
73	default: {
NEW 74	return this._notifyUnknownTransaction(chainId, log);	×
75	}
76	}
77	}
78	}
79
80	private decodeTransactionAdded(data: Hex) {
81	try {	4✔
82	return this.multiSendDecoder	4✔
83	.mapMultiSendTransactions(data)
84	.map(this.safeDecoder.decodeFunctionData);
85	} catch {
86	try {	4✔
87	return [this.safeDecoder.decodeFunctionData({ data })];	4✔
88	} catch {
89	return null;	4✔
90	}
91	}
92	}
93
94	private async _notifyUnknownTransaction(
95	chainId: string,
96	log: AlertLog,
97	): Promise<void> {
98	const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({	4✔
99	chainId,
100	safeAddress: log.address,
101	});
102
103	if (!emails.length) {	4!
NEW 104	this.loggingService.debug(	×
105	`An alert log for an invalid transaction with no verified emails associated was thrown for Safe ${log.address}`,
106	);
107	} else {
108	return this.emailApi.createMessage({	4✔
109	to: emails,
110	template: this.configurationService.getOrThrow<string>(
111	'email.templates.unknownRecoveryTx',
112	),
113	// TODO: subject and substitutions need to be set according to the template design
114	subject: 'Unknown transaction attempt',
115	substitutions: {},
116	});
117	}
118	}
119	}

safe-global / safe-client-gateway / 7061879100

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