10283448398

Committed 07 Aug 2024 11:28AM UTC coverage: 46.917% (-0.009%) from 46.926%

Build # 10283448398

Build Type

push

github

Committed by

web-flow

Commit Message

Implement Counterfactual Safes creation rate limit (#1801)

Adds a rate limitation controlled by a cache key before proceeding with Counterfactual Safes creation

Run Details

474 of 2882 branches covered (16.45%)

Branch coverage included in aggregate %.

2 of 9 new or added lines in 1 file covered. (22.22%)

1 existing line in 1 file now uncovered.

4548 of 7822 relevant lines covered (58.14%)

12.53 hits per line

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

20.37

/src/datasources/accounts/counterfactual-safes/counterfactual-safes.datasource.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';
import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';
import { LimitReachedError } from '@/datasources/network/entities/errors/limit-reached.error';
import { CounterfactualSafe } from '@/domain/accounts/counterfactual-safes/entities/counterfactual-safe.entity';
import { CreateCounterfactualSafeDto } from '@/domain/accounts/counterfactual-safes/entities/create-counterfactual-safe.dto.entity';
import { Account } from '@/domain/accounts/entities/account.entity';
import { ICounterfactualSafesDatasource } from '@/domain/interfaces/counterfactual-safes.datasource.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { Inject, Injectable, NotFoundException } from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class CounterfactualSafesDatasource
  implements ICounterfactualSafesDatasource
{
  private static readonly COUNTERFACTUAL_SAFES_CREATION_CACHE_PREFIX =
    'counterfactual_safes_creation';
  private readonly defaultExpirationTimeInSeconds: number;
  // Number of seconds for each rate-limit cycle
  private readonly counterfactualSafesCreationRateLimitPeriodSeconds: number;
  // Number of allowed calls on each rate-limit cycle
  private readonly counterfactualSafesCreationRateLimitCalls: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject('DB_INSTANCE') private readonly sql: postgres.Sql,
    @Inject(ICachedQueryResolver)
    private readonly cachedQueryResolver: CachedQueryResolver,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.counterfactualSafesCreationRateLimitPeriodSeconds =
      configurationService.getOrThrow(
        'accounts.counterfactualSafes.creationRateLimitPeriodSeconds',
      );
    this.counterfactualSafesCreationRateLimitCalls =
      configurationService.getOrThrow(
        'accounts.counterfactualSafes.creationRateLimitCalls',
      );
  }

  async createCounterfactualSafe(args: {
    account: Account;
    createCounterfactualSafeDto: CreateCounterfactualSafeDto;
  }): Promise<CounterfactualSafe> {
    await this.checkCreationRateLimit(args.account);
    const [counterfactualSafe] = await this.sql<CounterfactualSafe[]>`
      INSERT INTO counterfactual_safes 
      ${this.sql([this.mapCreationDtoToRow(args.account, args.createCounterfactualSafeDto)])}
      RETURNING *`;
    const { key } = CacheRouter.getCounterfactualSafesCacheDir(
      args.account.address,
    );
    await this.cacheService.deleteByKey(key);
    return counterfactualSafe;
  }

  async getCounterfactualSafe(args: {
    account: Account;
    chainId: string;
    predictedAddress: `0x${string}`;
  }): Promise<CounterfactualSafe> {
    const cacheDir = CacheRouter.getCounterfactualSafeCacheDir(
      args.chainId,
      args.predictedAddress,
    );
    const [counterfactualSafe] = await this.cachedQueryResolver.get<
      CounterfactualSafe[]
    >({
      cacheDir,
      query: this.sql<CounterfactualSafe[]>`
        SELECT * FROM counterfactual_safes 
        WHERE account_id = ${args.account.id}
          AND chain_id = ${args.chainId}
          AND predicted_address = ${args.predictedAddress}`,
      ttl: this.defaultExpirationTimeInSeconds,
    });

    if (!counterfactualSafe) {
      throw new NotFoundException('Error getting Counterfactual Safe.');
    }

    return counterfactualSafe;
  }

  getCounterfactualSafesForAccount(
    account: Account,
  ): Promise<CounterfactualSafe[]> {
    const cacheDir = CacheRouter.getCounterfactualSafesCacheDir(
      account.address,
    );
    return this.cachedQueryResolver.get<CounterfactualSafe[]>({
      cacheDir,
      query: this.sql<CounterfactualSafe[]>`
        SELECT * FROM counterfactual_safes WHERE account_id = ${account.id}`,
      ttl: this.defaultExpirationTimeInSeconds,
    });
  }

  async deleteCounterfactualSafe(args: {
    account: Account;
    chainId: string;
    predictedAddress: `0x${string}`;
  }): Promise<void> {
    try {
      const { count } = await this
        .sql`DELETE FROM counterfactual_safes WHERE chain_id = ${args.chainId} AND predicted_address = ${args.predictedAddress} AND account_id = ${args.account.id}`;
      if (count === 0) {
        this.loggingService.debug(
          `Error deleting Counterfactual Safe (${args.chainId}, ${args.predictedAddress}): not found`,
        );
      }
    } finally {
      await Promise.all([
        this.cacheService.deleteByKey(
          CacheRouter.getCounterfactualSafeCacheDir(
            args.chainId,
            args.predictedAddress,
          ).key,
        ),
        this.cacheService.deleteByKey(
          CacheRouter.getCounterfactualSafesCacheDir(args.account.address).key,
        ),
      ]);
    }
  }

  async deleteCounterfactualSafesForAccount(account: Account): Promise<void> {
    let deleted: CounterfactualSafe[] = [];
    try {
      const rows = await this.sql<
        CounterfactualSafe[]
      >`DELETE FROM counterfactual_safes WHERE account_id = ${account.id} RETURNING *`;
      deleted = rows;
    } finally {
      await this.cacheService.deleteByKey(
        CacheRouter.getCounterfactualSafesCacheDir(account.address).key,
      );
      await Promise.all(
        deleted.map((row) => {
          return this.cacheService.deleteByKey(
            CacheRouter.getCounterfactualSafeCacheDir(
              row.chain_id,
              row.predicted_address,
            ).key,
          );
        }),
      );
    }
  }

  private async checkCreationRateLimit(account: Account): Promise<void> {
    const current = await this.cacheService.increment(
      CacheRouter.getRateLimitCacheKey(
        `${CounterfactualSafesDatasource.COUNTERFACTUAL_SAFES_CREATION_CACHE_PREFIX}_${account.address}`,
      ),
      this.counterfactualSafesCreationRateLimitPeriodSeconds,
    );
    if (current > this.counterfactualSafesCreationRateLimitCalls) {
      this.loggingService.warn(
        `Limit of ${this.counterfactualSafesCreationRateLimitCalls} reached for account ${account.address}`,
      );
      throw new LimitReachedError();
    }
  }

  private mapCreationDtoToRow(
    account: Account,
    createCounterfactualSafeDto: CreateCounterfactualSafeDto,
  ): Partial<CounterfactualSafe> {
    return {
      account_id: account.id,
      chain_id: createCounterfactualSafeDto.chainId,
      creator: account.address,
      fallback_handler: createCounterfactualSafeDto.fallbackHandler,
      owners: createCounterfactualSafeDto.owners,
      predicted_address: createCounterfactualSafeDto.predictedAddress,
      salt_nonce: createCounterfactualSafeDto.saltNonce,
      singleton_address: createCounterfactualSafeDto.singletonAddress,
      threshold: createCounterfactualSafeDto.threshold,
    };
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
2	import { CacheRouter } from '@/datasources/cache/cache.router';	16✔
3	import {	16✔
4	CacheService,
5	ICacheService,
6	} from '@/datasources/cache/cache.service.interface';
7	import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';	16✔
8	import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';	16✔
9	import { LimitReachedError } from '@/datasources/network/entities/errors/limit-reached.error';	16✔
10	import { CounterfactualSafe } from '@/domain/accounts/counterfactual-safes/entities/counterfactual-safe.entity';
11	import { CreateCounterfactualSafeDto } from '@/domain/accounts/counterfactual-safes/entities/create-counterfactual-safe.dto.entity';
12	import { Account } from '@/domain/accounts/entities/account.entity';
13	import { ICounterfactualSafesDatasource } from '@/domain/interfaces/counterfactual-safes.datasource.interface';
14	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
15	import { Inject, Injectable, NotFoundException } from '@nestjs/common';	16✔
16	import postgres from 'postgres';	16✔
17
18	@Injectable()
19	export class CounterfactualSafesDatasource	16✔
20	implements ICounterfactualSafesDatasource
21	{
22	private static readonly COUNTERFACTUAL_SAFES_CREATION_CACHE_PREFIX =	16✔
23	'counterfactual_safes_creation';
24	private readonly defaultExpirationTimeInSeconds: number;
25	// Number of seconds for each rate-limit cycle
26	private readonly counterfactualSafesCreationRateLimitPeriodSeconds: number;
27	// Number of allowed calls on each rate-limit cycle
28	private readonly counterfactualSafesCreationRateLimitCalls: number;
29
30	constructor(
31	@Inject(CacheService) private readonly cacheService: ICacheService,	×
32	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
33	@Inject(ICachedQueryResolver)
34	private readonly cachedQueryResolver: CachedQueryResolver,	×
35	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
36	@Inject(IConfigurationService)
37	private readonly configurationService: IConfigurationService,	×
38	) {
39	this.defaultExpirationTimeInSeconds =	×
40	this.configurationService.getOrThrow<number>(
41	'expirationTimeInSeconds.default',
42	);
NEW 43	this.counterfactualSafesCreationRateLimitPeriodSeconds =	×
44	configurationService.getOrThrow(
45	'accounts.counterfactualSafes.creationRateLimitPeriodSeconds',
46	);
NEW 47	this.counterfactualSafesCreationRateLimitCalls =	×
48	configurationService.getOrThrow(
49	'accounts.counterfactualSafes.creationRateLimitCalls',
50	);
51	}
52
53	async createCounterfactualSafe(args: {
54	account: Account;
55	createCounterfactualSafeDto: CreateCounterfactualSafeDto;
56	}): Promise<CounterfactualSafe> {
NEW 57	await this.checkCreationRateLimit(args.account);	×
UNCOV 58	const [counterfactualSafe] = await this.sql<CounterfactualSafe[]>`	×
59	INSERT INTO counterfactual_safes
60	${this.sql([this.mapCreationDtoToRow(args.account, args.createCounterfactualSafeDto)])}
61	RETURNING *`;
62	const { key } = CacheRouter.getCounterfactualSafesCacheDir(	×
63	args.account.address,
64	);
65	await this.cacheService.deleteByKey(key);	×
66	return counterfactualSafe;	×
67	}
68
69	async getCounterfactualSafe(args: {
70	account: Account;
71	chainId: string;
72	predictedAddress: `0x${string}`;
73	}): Promise<CounterfactualSafe> {
74	const cacheDir = CacheRouter.getCounterfactualSafeCacheDir(	×
75	args.chainId,
76	args.predictedAddress,
77	);
78	const [counterfactualSafe] = await this.cachedQueryResolver.get<	×
79	CounterfactualSafe[]
80	>({
81	cacheDir,
82	query: this.sql<CounterfactualSafe[]>`
83	SELECT * FROM counterfactual_safes
84	WHERE account_id = ${args.account.id}
85	AND chain_id = ${args.chainId}
86	AND predicted_address = ${args.predictedAddress}`,
87	ttl: this.defaultExpirationTimeInSeconds,
88	});
89
90	if (!counterfactualSafe) {	×
91	throw new NotFoundException('Error getting Counterfactual Safe.');	×
92	}
93
94	return counterfactualSafe;	×
95	}
96
97	getCounterfactualSafesForAccount(
98	account: Account,
99	): Promise<CounterfactualSafe[]> {
100	const cacheDir = CacheRouter.getCounterfactualSafesCacheDir(	×
101	account.address,
102	);
103	return this.cachedQueryResolver.get<CounterfactualSafe[]>({	×
104	cacheDir,
105	query: this.sql<CounterfactualSafe[]>`
106	SELECT * FROM counterfactual_safes WHERE account_id = ${account.id}`,
107	ttl: this.defaultExpirationTimeInSeconds,
108	});
109	}
110
111	async deleteCounterfactualSafe(args: {
112	account: Account;
113	chainId: string;
114	predictedAddress: `0x${string}`;
115	}): Promise<void> {
116	try {	×
117	const { count } = await this	×
118	.sql`DELETE FROM counterfactual_safes WHERE chain_id = ${args.chainId} AND predicted_address = ${args.predictedAddress} AND account_id = ${args.account.id}`;
119	if (count === 0) {	×
120	this.loggingService.debug(	×
121	`Error deleting Counterfactual Safe (${args.chainId}, ${args.predictedAddress}): not found`,
122	);
123	}
124	} finally {
125	await Promise.all([	×
126	this.cacheService.deleteByKey(
127	CacheRouter.getCounterfactualSafeCacheDir(
128	args.chainId,
129	args.predictedAddress,
130	).key,
131	),
132	this.cacheService.deleteByKey(
133	CacheRouter.getCounterfactualSafesCacheDir(args.account.address).key,
134	),
135	]);
136	}
137	}
138
139	async deleteCounterfactualSafesForAccount(account: Account): Promise<void> {
140	let deleted: CounterfactualSafe[] = [];	×
141	try {	×
142	const rows = await this.sql<	×
143	CounterfactualSafe[]
144	>`DELETE FROM counterfactual_safes WHERE account_id = ${account.id} RETURNING *`;
145	deleted = rows;	×
146	} finally {
147	await this.cacheService.deleteByKey(	×
148	CacheRouter.getCounterfactualSafesCacheDir(account.address).key,
149	);
150	await Promise.all(	×
151	deleted.map((row) => {
152	return this.cacheService.deleteByKey(	×
153	CacheRouter.getCounterfactualSafeCacheDir(
154	row.chain_id,
155	row.predicted_address,
156	).key,
157	);
158	}),
159	);
160	}
161	}
162
163	private async checkCreationRateLimit(account: Account): Promise<void> {
NEW 164	const current = await this.cacheService.increment(	×
165	CacheRouter.getRateLimitCacheKey(
166	`${CounterfactualSafesDatasource.COUNTERFACTUAL_SAFES_CREATION_CACHE_PREFIX}_${account.address}`,
167	),
168	this.counterfactualSafesCreationRateLimitPeriodSeconds,
169	);
NEW 170	if (current > this.counterfactualSafesCreationRateLimitCalls) {	×
NEW 171	this.loggingService.warn(	×
172	`Limit of ${this.counterfactualSafesCreationRateLimitCalls} reached for account ${account.address}`,
173	);
NEW 174	throw new LimitReachedError();	×
175	}
176	}
177
178	private mapCreationDtoToRow(
179	account: Account,
180	createCounterfactualSafeDto: CreateCounterfactualSafeDto,
181	): Partial<CounterfactualSafe> {
182	return {	×
183	account_id: account.id,
184	chain_id: createCounterfactualSafeDto.chainId,
185	creator: account.address,
186	fallback_handler: createCounterfactualSafeDto.fallbackHandler,
187	owners: createCounterfactualSafeDto.owners,
188	predicted_address: createCounterfactualSafeDto.predictedAddress,
189	salt_nonce: createCounterfactualSafeDto.saltNonce,
190	singleton_address: createCounterfactualSafeDto.singletonAddress,
191	threshold: createCounterfactualSafeDto.threshold,
192	};
193	}
194	}

safe-global / safe-client-gateway / 10283448398

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