7129166646

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

Build # 7129166646

Build Type

push

github

Committed by

web-flow

Commit Message

feat: decode recovered Safe setup (#918)

Run Details

1461 of 1776 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 15 new or added lines in 1 file covered. (13.33%)

5 existing lines in 2 files now uncovered.

5367 of 5894 relevant lines covered (91.06%)

151.92 hits per line

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

32.35

/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 {
      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	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({	12✔
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
NEW 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': {
NEW 62	const [ownerToAdd, newThreshold] = decodedTransaction.args;	×
63
NEW 64	safe.owners.push(ownerToAdd);	×
NEW 65	safe.threshold = Number(newThreshold);	×
UNCOV 66	break;	×
67	}
68	case 'removeOwner': {
NEW 69	const [, ownerToRemove, newThreshold] = decodedTransaction.args;	×
70
NEW 71	safe.owners = safe.owners.filter((owner) => {	×
NEW 72	return owner.toLowerCase() !== ownerToRemove.toLowerCase();	×
73	});
NEW 74	safe.threshold = Number(newThreshold);	×
UNCOV 75	break;	×
76	}
77	case 'swapOwner': {
NEW 78	const [, ownerToRemove, ownerToAdd] = decodedTransaction.args;	×
79
NEW 80	safe.owners = safe.owners.map((owner) => {	×
NEW 81	return owner.toLowerCase() === ownerToRemove.toLowerCase()	×
82	? ownerToAdd
83	: owner;
84	});
UNCOV 85	break;	×
86	}
87	case 'changeThreshold': {
NEW 88	const [newThreshold] = decodedTransaction.args;	×
89
NEW 90	safe.threshold = Number(newThreshold);	×
UNCOV 91	break;	×
92	}
93	default: {
94	return this._notifyUnknownTransaction(chainId, log);	×
95	}
96	}
97	}
98	}
99
100	private decodeTransactionAdded(data: Hex) {
101	try {	×
102	return this.multiSendDecoder	×
103	.mapMultiSendTransactions(data)
104	.map(this.safeDecoder.decodeFunctionData);
105	} catch {
106	try {	×
107	return [this.safeDecoder.decodeFunctionData({ data })];	×
108	} catch {
109	return null;	×
110	}
111	}
112	}
113
114	private async _notifyUnknownTransaction(
115	chainId: string,
116	log: AlertLog,
117	): Promise<void> {
118	const emails = await this.emailRepository.getVerifiedEmailsBySafeAddress({	×
119	chainId,
120	safeAddress: log.address,
121	});
122
123	if (!emails.length) {	×
124	this.loggingService.debug(	×
125	`An alert log for an invalid transaction with no verified emails associated was thrown for Safe ${log.address}`,
126	);
127	} else {
128	return this.emailApi.createMessage({	×
129	to: emails,
130	template: this.configurationService.getOrThrow<string>(
131	'email.templates.unknownRecoveryTx',
132	),
133	// TODO: subject and substitutions need to be set according to the template design
134	subject: 'Unknown transaction attempt',
135	substitutions: {},
136	});
137	}
138	}
139	}

safe-global / safe-client-gateway / 7129166646

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