7914567940

Committed 15 Feb 2024 10:35AM UTC coverage: 93.327% (+1.2%) from 92.081%

Build # 7914567940

Build Type

Pull #1144

github

Committed by

iamacook

Commit Message

Merge branch 'main' into limit-addresses-mapper

Pull Request Pull Request #1144: Add officiality check for Safe and MultiSend contracts in `LimitAddressesMapper`

Run Details

1573 of 1882 branches covered (83.58%)

Branch coverage included in aggregate %.

59 of 60 new or added lines in 4 files covered. (98.33%)

2 existing lines in 1 file now uncovered.

5993 of 6225 relevant lines covered (96.27%)

178.12 hits per line

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

0.0

/src/domain/relay/relay.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import { Hex } from 'viem/types/misc';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { IRelayApi } from '@/domain/interfaces/relay-api.interface';
import { LimitAddressesMapper } from '@/domain/relay/limit-addresses.mapper';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';

// TODO: Move to error folder and create exception filter
class RelayLimitReachedError extends Error {
  constructor(
    readonly address: Hex,
    readonly current: number,
    readonly limit: number,
  ) {
    super(
      `Relay limit reached for ${address} | current: ${current} | limit: ${limit}`,
    );
  }
}

@Injectable({})
export class RelayRepository {
  // Number of relay requests per ttl
  private readonly limit: number;

  constructor(
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService) configurationService: IConfigurationService,
    private readonly limitAddressesMapper: LimitAddressesMapper,
    private readonly relayApi: IRelayApi,
  ) {
    this.limit = configurationService.getOrThrow('relay.limit');
  }

  async relay(relayPayload: {
    chainId: string;
    to: string;
    data: string;
    gasLimit?: string;
  }): Promise<{ taskId: string }> {
    const relayAddresses =
      await this.limitAddressesMapper.getLimitAddresses(relayPayload);
    for (const address of relayAddresses) {
      const canRelay = await this.canRelay({
        chainId: relayPayload.chainId,
        address,
      });
      if (!canRelay.result) {
        const error = new RelayLimitReachedError(
          address,
          canRelay.currentCount,
          this.limit,
        );
        this.loggingService.info(error.message);
        throw error;
      }
    }

    return this.relayApi.relay(relayPayload);
  }

  private async canRelay(args: {
    chainId: string;
    address: string;
  }): Promise<{ result: boolean; currentCount: number }> {
    const currentCount = await this.getRelayCount(args);
    return { result: currentCount < this.limit, currentCount };
  }

  getRelayCount(args: { chainId: string; address: string }): Promise<number> {
    return this.relayApi.getRelayCount(args);
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	×
2	import { Hex } from 'viem/types/misc';
3	import { IConfigurationService } from '@/config/configuration.service.interface';	×
4	import { IRelayApi } from '@/domain/interfaces/relay-api.interface';	×
5	import { LimitAddressesMapper } from '@/domain/relay/limit-addresses.mapper';	×
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	×
7
8	// TODO: Move to error folder and create exception filter
9	class RelayLimitReachedError extends Error {
10	constructor(
11	readonly address: Hex,	×
12	readonly current: number,	×
13	readonly limit: number,	×
14	) {
15	super(	×
16	`Relay limit reached for ${address} \| current: ${current} \| limit: ${limit}`,
17	);
18	}
19	}
20
21	@Injectable({})
22	export class RelayRepository {	×
23	// Number of relay requests per ttl
24	private readonly limit: number;
25
26	constructor(
27	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
28	@Inject(IConfigurationService) configurationService: IConfigurationService,
29	private readonly limitAddressesMapper: LimitAddressesMapper,	×
30	private readonly relayApi: IRelayApi,	×
31	) {
32	this.limit = configurationService.getOrThrow('relay.limit');	×
33	}
34
35	async relay(relayPayload: {
36	chainId: string;
37	to: string;
38	data: string;
39	gasLimit?: string;
40	}): Promise<{ taskId: string }> {
41	const relayAddresses =
NEW 42	await this.limitAddressesMapper.getLimitAddresses(relayPayload);	×
43	for (const address of relayAddresses) {	×
44	const canRelay = await this.canRelay({	×
45	chainId: relayPayload.chainId,
46	address,
47	});
48	if (!canRelay.result) {	×
49	const error = new RelayLimitReachedError(	×
50	address,
51	canRelay.currentCount,
52	this.limit,
53	);
54	this.loggingService.info(error.message);	×
55	throw error;	×
56	}
57	}
58
59	return this.relayApi.relay(relayPayload);	×
60	}
61
62	private async canRelay(args: {
63	chainId: string;
64	address: string;
65	}): Promise<{ result: boolean; currentCount: number }> {
66	const currentCount = await this.getRelayCount(args);	×
67	return { result: currentCount < this.limit, currentCount };	×
68	}
69
70	getRelayCount(args: { chainId: string; address: string }): Promise<number> {
71	return this.relayApi.getRelayCount(args);	×
72	}
73	}

safe-global / safe-client-gateway / 7914567940

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