7129168097

Committed 07 Dec 2023 01:54PM UTC coverage: 88.898% (-0.1%) from 89.022%

Build # 7129168097

Build Type

push

github

Committed by

web-flow

Commit Message

fix: batched recovery proposal decoding (#917)

Run Details

1458 of 1778 branches covered (0.0%)

Branch coverage included in aggregate %.

0 of 5 new or added lines in 1 file covered. (0.0%)

4 existing lines in 2 files now uncovered.

5364 of 5896 relevant lines covered (90.98%)

151.44 hits per line

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

30.56

/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';
import { ISafeRepository } from '@/domain/safe/safe.repository.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,
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
  ) {}

  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);
    }

    const safe = await this.safeRepository.getSafe({
      chainId,
      address: decodedEvent.args.to,
    });

    for (const decodedTransaction of decodedTransactions) {
      switch (decodedTransaction.functionName) {
        case 'addOwnerWithThreshold': {
          const [ownerToAdd, newThreshold] = decodedTransaction.args;

          safe.owners.push(ownerToAdd);
          safe.threshold = Number(newThreshold);
          break;
        }
        case 'removeOwner': {
          const [, ownerToRemove, newThreshold] = decodedTransaction.args;

          safe.owners = safe.owners.filter((owner) => {
            return owner.toLowerCase() !== ownerToRemove.toLowerCase();
          });
          safe.threshold = Number(newThreshold);
          break;
        }
        case 'swapOwner': {
          const [, ownerToRemove, ownerToAdd] = decodedTransaction.args;

          safe.owners = safe.owners.map((owner) => {
            return owner.toLowerCase() === ownerToRemove.toLowerCase()
              ? ownerToAdd
              : owner;
          });
          break;
        }
        case 'changeThreshold': {
          const [newThreshold] = decodedTransaction.args;

          safe.threshold = Number(newThreshold);
          break;
        }
        default: {
          return this._notifyUnknownTransaction(chainId, log);
        }
      }
    }
  }

  private decodeTransactionAdded(data: Hex) {
    try {
      const decoded = this.safeDecoder.decodeFunctionData({ data });

      if (decoded.functionName !== 'execTransaction') {
        return [decoded];
      }

      // TODO: Check "validity" of multiSend transaction:
      // - calling official deployment
      // - all transactions are to current Safe
      // - all transactions are owner management
      return this.multiSendDecoder
        .mapMultiSendTransactions(decoded.args[2])
        .flatMap(({ data }) => 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	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	62✔
15
16	@Injectable()
17	export class AlertsRepository implements IAlertsRepository {	62✔
18	constructor(
19	@Inject(IAlertsApi)
20	private readonly alertsApi: IAlertsApi,	482✔
21	@Inject(IEmailApi)
22	private readonly emailApi: IEmailApi,	482✔
23	@Inject(IEmailRepository)
24	private readonly emailRepository: IEmailRepository,	482✔
25	private readonly delayModifierDecoder: DelayModifierDecoder,	482✔
26	private readonly safeDecoder: SafeDecoder,	482✔
27	private readonly multiSendDecoder: MultiSendDecoder,	482✔
28	@Inject(LoggingService)
29	private readonly loggingService: ILoggingService,	482✔
30	@Inject(IConfigurationService)
31	private readonly configurationService: IConfigurationService,	482✔
32	@Inject(ISafeRepository)
33	private readonly safeRepository: ISafeRepository,	482✔
34	) {}
35
36	async addContracts(contracts: Array<AlertsRegistration>): Promise<void> {
37	await this.alertsApi.addContracts(contracts);	6✔
38	}
39
40	async handleAlertLog(chainId: string, log: AlertLog): Promise<void> {
41	const decodedEvent = this.delayModifierDecoder.decodeEventLog({	8✔
42	data: log.data as Hex,
43	topics: log.topics as [Hex, Hex, Hex],
44	});
45
46	const decodedTransactions = this.decodeTransactionAdded(	×
47	decodedEvent.args.data,
48	);
49
50	if (!decodedTransactions) {	×
51	return this._notifyUnknownTransaction(chainId, log);	×
52	}
53
54	const safe = await this.safeRepository.getSafe({	×
55	chainId,
56	address: decodedEvent.args.to,
57	});
58
59	for (const decodedTransaction of decodedTransactions) {	×
60	switch (decodedTransaction.functionName) {	×
61	case 'addOwnerWithThreshold': {
62	const [ownerToAdd, newThreshold] = decodedTransaction.args;	×
63
64	safe.owners.push(ownerToAdd);	×
65	safe.threshold = Number(newThreshold);	×
66	break;	×
67	}
68	case 'removeOwner': {
69	const [, ownerToRemove, newThreshold] = decodedTransaction.args;	×
70
71	safe.owners = safe.owners.filter((owner) => {	×
72	return owner.toLowerCase() !== ownerToRemove.toLowerCase();	×
73	});
74	safe.threshold = Number(newThreshold);	×
75	break;	×
76	}
77	case 'swapOwner': {
78	const [, ownerToRemove, ownerToAdd] = decodedTransaction.args;	×
79
80	safe.owners = safe.owners.map((owner) => {	×
81	return owner.toLowerCase() === ownerToRemove.toLowerCase()	×
82	? ownerToAdd
83	: owner;
84	});
85	break;	×
86	}
87	case 'changeThreshold': {
88	const [newThreshold] = decodedTransaction.args;	×
89
90	safe.threshold = Number(newThreshold);	×
91	break;	×
92	}
93	default: {
94	return this._notifyUnknownTransaction(chainId, log);	×
95	}
96	}
97	}
98	}
99
100	private decodeTransactionAdded(data: Hex) {
101	try {	×
NEW 102	const decoded = this.safeDecoder.decodeFunctionData({ data });	×
103
NEW 104	if (decoded.functionName !== 'execTransaction') {	×
NEW 105	return [decoded];	×
106	}
107
108	// TODO: Check "validity" of multiSend transaction:
109	// - calling official deployment
110	// - all transactions are to current Safe
111	// - all transactions are owner management
UNCOV 112	return this.multiSendDecoder	×
113	.mapMultiSendTransactions(decoded.args[2])
NEW 114	.flatMap(({ data }) => this.safeDecoder.decodeFunctionData({ data }));	×
115	} catch {
NEW 116	return null;	×
117	}
118	}
119
120	private async _notifyUnknownTransaction(
121	chainId: string,
122	log: AlertLog,
123	): Promise<void> {
124	const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({	×
125	chainId,
126	safeAddress: log.address,
127	});
128
129	if (!emails.length) {	×
130	this.loggingService.debug(	×
131	`An alert log for an invalid transaction with no verified emails associated was thrown for Safe ${log.address}`,
132	);
133	} else {
134	return this.emailApi.createMessage({	×
135	to: emails,
136	template: this.configurationService.getOrThrow<string>(
137	'email.templates.unknownRecoveryTx',
138	),
139	// TODO: subject and substitutions need to be set according to the template design
140	subject: 'Unknown transaction attempt',
141	substitutions: {},
142	});
143	}
144	}
145	}

safe-global / safe-client-gateway / 7129168097

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