11050283546

Committed 25 Sep 2024 03:17PM UTC coverage: 90.796% (-0.03%) from 90.825%

Build # 11050283546

Build Type

push

github

Committed by

web-flow

Commit Message

Ensure event signature is present in topics (#1961)

Adds new `EventTopicsSchema` and uses it in relevant schemas, removing the unnecessary casting thereafter:

- Add/use `EventTopicsSchema`.
- Remove unnecessary topic casting.
- Add/update tests accordingly.

Run Details

2564 of 3198 branches covered (80.18%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 5 files covered. (85.71%)

1 existing line in 1 file now uncovered.

8396 of 8873 relevant lines covered (94.62%)

445.14 hits per line

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

24.66

/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-registration.entity';
import { AlertsDeletion } from '@/domain/alerts/entities/alerts-deletion.entity';
import { AlertLog } from '@/routes/alerts/entities/alert.dto.entity';
import { DelayModifierDecoder } from '@/domain/alerts/contracts/decoders/delay-modifier-decoder.helper';
import { SafeDecoder } from '@/domain/contracts/decoders/safe-decoder.helper';
import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { Safe } from '@/domain/safe/entities/safe.entity';

@Injectable()
export class AlertsRepository implements IAlertsRepository {
  constructor(
    @Inject(IAlertsApi)
    private readonly alertsApi: IAlertsApi,
    private readonly delayModifierDecoder: DelayModifierDecoder,
    private readonly safeDecoder: SafeDecoder,
    private readonly multiSendDecoder: MultiSendDecoder,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
  ) {}

  async addContract(contract: AlertsRegistration): Promise<void> {
    await this.alertsApi.addContract(contract);
  }

  async deleteContract(contract: AlertsDeletion): Promise<void> {
    await this.alertsApi.deleteContract(contract);
  }

  async handleAlertLog(chainId: string, log: AlertLog): Promise<void> {
    const moduleAddress = log.address;

    const { safes } = await this.safeRepository.getSafesByModule({
      chainId,
      moduleAddress,
    });

    if (safes.length === 0) {
      this.loggingService.debug(
        `An alert for a module that is not activated on a Safe was received. moduleAddress=${moduleAddress}`,
      );
      return;
    }

    // Recovery module is deployed per Safe so we can assume that it is only enabled on one
    const safeAddress = safes[0];

    try {
      const safe = await this.safeRepository.getSafe({
        chainId,
        address: safeAddress,
      });

      const decodedEvent = this.delayModifierDecoder.decodeEventLog(log);
      const decodedTransactions = this._decodeTransactionAdded(
        decodedEvent.args.data,
      );

      // eslint-disable-next-line @typescript-eslint/no-unused-vars
      const newSafeState = this._mapSafeSetup({
        safe,
        decodedTransactions,
      });

      // TODO: Notify the user about the new Safe state
    } catch {
      // TODO: Notify the user about the unknown transaction
    }
  }

  private _decodeTransactionAdded(
    data: Hex,
  ): Array<ReturnType<typeof this._decodeRecoveryTransaction>> {
    try {
      return this.multiSendDecoder
        .mapMultiSendTransactions(data)
        .flatMap((multiSend) => {
          return this._decodeRecoveryTransaction(multiSend.data);
        });
    } catch {
      return [this._decodeRecoveryTransaction(data)];
    }
  }

  private _decodeRecoveryTransaction(
    data: Hex,
  ): ReturnType<typeof this.safeDecoder.decodeFunctionData> {
    const decoded = this.safeDecoder.decodeFunctionData({ data });

    const isRecoveryTransaction = [
      'addOwnerWithThreshold',
      'removeOwner',
      'swapOwner',
      'changeThreshold',
    ].includes(decoded.functionName);

    if (!isRecoveryTransaction) {
      throw new Error('Unknown recovery transaction');
    }

    return decoded;
  }

  private _mapSafeSetup(args: {
    safe: Safe;
    decodedTransactions: Array<ReturnType<SafeDecoder['decodeFunctionData']>>;
  }): Safe {
    return args.decodedTransactions.reduce((newSafe, decodedTransaction) => {
      switch (decodedTransaction.functionName) {
        case 'addOwnerWithThreshold': {
          const [ownerToAdd, newThreshold] = decodedTransaction.args;

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

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

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

          newSafe.threshold = Number(newThreshold);
          break;
        }
        default: {
          throw new Error(
            `Unknown recovery transaction ${decodedTransaction?.functionName}`,
          );
        }
      }

      return newSafe;
    }, structuredClone(args.safe));
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	96✔
2	import { Hex } from 'viem';
3	import { IAlertsRepository } from '@/domain/alerts/alerts.repository.interface';
4	import { IAlertsApi } from '@/domain/interfaces/alerts-api.interface';	96✔
5	import { AlertsRegistration } from '@/domain/alerts/entities/alerts-registration.entity';
6	import { AlertsDeletion } from '@/domain/alerts/entities/alerts-deletion.entity';
7	import { AlertLog } from '@/routes/alerts/entities/alert.dto.entity';
8	import { DelayModifierDecoder } from '@/domain/alerts/contracts/decoders/delay-modifier-decoder.helper';	96✔
9	import { SafeDecoder } from '@/domain/contracts/decoders/safe-decoder.helper';	96✔
10	import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';	96✔
11	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	96✔
12	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	96✔
13	import { Safe } from '@/domain/safe/entities/safe.entity';
14
15	@Injectable()
16	export class AlertsRepository implements IAlertsRepository {	96✔
17	constructor(
18	@Inject(IAlertsApi)
19	private readonly alertsApi: IAlertsApi,	36✔
20	private readonly delayModifierDecoder: DelayModifierDecoder,	36✔
21	private readonly safeDecoder: SafeDecoder,	36✔
22	private readonly multiSendDecoder: MultiSendDecoder,	36✔
23	@Inject(LoggingService)
24	private readonly loggingService: ILoggingService,	36✔
25	@Inject(ISafeRepository)
26	private readonly safeRepository: ISafeRepository,	36✔
27	) {}
28
29	async addContract(contract: AlertsRegistration): Promise<void> {
30	await this.alertsApi.addContract(contract);	2✔
31	}
32
33	async deleteContract(contract: AlertsDeletion): Promise<void> {
34	await this.alertsApi.deleteContract(contract);	6✔
35	}
36
37	async handleAlertLog(chainId: string, log: AlertLog): Promise<void> {
38	const moduleAddress = log.address;	6✔
39
40	const { safes } = await this.safeRepository.getSafesByModule({	6✔
41	chainId,
42	moduleAddress,
43	});
44
45	if (safes.length === 0) {	×
46	this.loggingService.debug(	×
47	`An alert for a module that is not activated on a Safe was received. moduleAddress=${moduleAddress}`,
48	);
49	return;	×
50	}
51
52	// Recovery module is deployed per Safe so we can assume that it is only enabled on one
53	const safeAddress = safes[0];	×
54
55	try {	×
56	const safe = await this.safeRepository.getSafe({	×
57	chainId,
58	address: safeAddress,
59	});
60
NEW 61	const decodedEvent = this.delayModifierDecoder.decodeEventLog(log);	×
UNCOV 62	const decodedTransactions = this._decodeTransactionAdded(	×
63	decodedEvent.args.data,
64	);
65
66	// eslint-disable-next-line @typescript-eslint/no-unused-vars
67	const newSafeState = this._mapSafeSetup({	×
68	safe,
69	decodedTransactions,
70	});
71
72	// TODO: Notify the user about the new Safe state
73	} catch {
74	// TODO: Notify the user about the unknown transaction
75	}
76	}
77
78	private _decodeTransactionAdded(
79	data: Hex,
80	): Array<ReturnType<typeof this._decodeRecoveryTransaction>> {
81	try {	×
82	return this.multiSendDecoder	×
83	.mapMultiSendTransactions(data)
84	.flatMap((multiSend) => {
85	return this._decodeRecoveryTransaction(multiSend.data);	×
86	});
87	} catch {
88	return [this._decodeRecoveryTransaction(data)];	×
89	}
90	}
91
92	private _decodeRecoveryTransaction(
93	data: Hex,
94	): ReturnType<typeof this.safeDecoder.decodeFunctionData> {
95	const decoded = this.safeDecoder.decodeFunctionData({ data });	×
96
97	const isRecoveryTransaction = [	×
98	'addOwnerWithThreshold',
99	'removeOwner',
100	'swapOwner',
101	'changeThreshold',
102	].includes(decoded.functionName);
103
104	if (!isRecoveryTransaction) {	×
105	throw new Error('Unknown recovery transaction');	×
106	}
107
108	return decoded;	×
109	}
110
111	private _mapSafeSetup(args: {
112	safe: Safe;
113	decodedTransactions: Array<ReturnType<SafeDecoder['decodeFunctionData']>>;
114	}): Safe {
115	return args.decodedTransactions.reduce((newSafe, decodedTransaction) => {	×
116	switch (decodedTransaction.functionName) {	×
117	case 'addOwnerWithThreshold': {
118	const [ownerToAdd, newThreshold] = decodedTransaction.args;	×
119
120	newSafe.owners.push(ownerToAdd);	×
121	newSafe.threshold = Number(newThreshold);	×
122	break;	×
123	}
124	case 'removeOwner': {
125	const [, ownerToRemove, newThreshold] = decodedTransaction.args;	×
126
127	newSafe.owners = newSafe.owners.filter((owner) => {	×
128	return owner.toLowerCase() !== ownerToRemove.toLowerCase();	×
129	});
130	newSafe.threshold = Number(newThreshold);	×
131	break;	×
132	}
133	case 'swapOwner': {
134	const [, ownerToRemove, ownerToAdd] = decodedTransaction.args;	×
135
136	newSafe.owners = newSafe.owners.map((owner) => {	×
137	return owner.toLowerCase() === ownerToRemove.toLowerCase()	×
138	? ownerToAdd
139	: owner;
140	});
141	break;	×
142	}
143	case 'changeThreshold': {
144	const [newThreshold] = decodedTransaction.args;	×
145
146	newSafe.threshold = Number(newThreshold);	×
147	break;	×
148	}
149	default: {
150	throw new Error(	×
151	`Unknown recovery transaction ${decodedTransaction?.functionName}`,	×
152	);
153	}
154	}
155
156	return newSafe;	×
157	}, structuredClone(args.safe));
158	}
159	}

safe-global / safe-client-gateway / 11050283546

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