7103327737

Committed 05 Dec 2023 04:00PM UTC coverage: 89.081% (-0.2%) from 89.273%

Build # 7103327737

Build Type

Pull #894

github

Committed by

iamacook

Commit Message

Merge branch 'main' into add-alerts-decoders-module

Pull Request Pull Request #894: Add AlertsDecodersModule and TestAlertsDecodersModule

Run Details

1439 of 1758 branches covered (0.0%)

Branch coverage included in aggregate %.

7 of 20 new or added lines in 4 files covered. (35.0%)

4 existing lines in 2 files now uncovered.

5275 of 5779 relevant lines covered (91.28%)

153.86 hits per line

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

40.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.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) {
      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,	482✔
20	@Inject(IEmailApi)
21	private readonly emailApi: IEmailApi,	482✔
22	@Inject(IEmailRepository)
23	private readonly emailRepository: IEmailRepository,	482✔
24	private readonly delayModifierDecoder: DelayModifierDecoder,	482✔
25	private readonly safeDecoder: SafeDecoder,	482✔
26	private readonly multiSendDecoder: MultiSendDecoder,	482✔
27	@Inject(LoggingService)
28	private readonly loggingService: ILoggingService,	482✔
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	482✔
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({	4✔
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> {
98	const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({	×
99	chainId,
100	safeAddress: log.address,
101	});
102
103	if (!emails.length) {	×
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({	×
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 / 7103327737

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