10556232829

Committed 25 Aug 2024 04:36PM UTC coverage: 46.706% (+0.05%) from 46.656%

Build # 10556232829

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Remove auth for GET Counterfactual Safes endpoints

Run Details

496 of 3001 branches covered (16.53%)

Branch coverage included in aggregate %.

0 of 5 new or added lines in 4 files covered. (0.0%)

1 existing line in 1 file now uncovered.

4729 of 8186 relevant lines covered (57.77%)

12.34 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: {
    address: `0x${string}`;
    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 = (SELECT id FROM accounts WHERE address = ${args.address})
          AND chain_id = ${args.chainId}
          AND predicted_address = ${args.predictedAddress}`,
      ttl: this.defaultExpirationTimeInSeconds,
    });

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

    return counterfactualSafe;
  }

  getCounterfactualSafesForAddress(
    address: `0x${string}`,
  ): Promise<CounterfactualSafe[]> {
    const cacheDir = CacheRouter.getCounterfactualSafesCacheDir(address);
    return this.cachedQueryResolver.get<CounterfactualSafe[]>({
      cacheDir,
      query: this.sql<CounterfactualSafe[]>`
        SELECT * FROM counterfactual_safes WHERE account_id = 
          (SELECT id FROM accounts WHERE address = ${address})`,
      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	);
43	this.counterfactualSafesCreationRateLimitPeriodSeconds =	×
44	configurationService.getOrThrow(
45	'accounts.counterfactualSafes.creationRateLimitPeriodSeconds',
46	);
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> {
57	await this.checkCreationRateLimit(args.account);	×
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	address: `0x${string}`;
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 = (SELECT id FROM accounts WHERE address = ${args.address})
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	getCounterfactualSafesForAddress(
98	address: `0x${string}`,
99	): Promise<CounterfactualSafe[]> {
NEW 100	const cacheDir = CacheRouter.getCounterfactualSafesCacheDir(address);	×
UNCOV 101	return this.cachedQueryResolver.get<CounterfactualSafe[]>({	×
102	cacheDir,
103	query: this.sql<CounterfactualSafe[]>`
104	SELECT * FROM counterfactual_safes WHERE account_id =
105	(SELECT id FROM accounts WHERE address = ${address})`,
106	ttl: this.defaultExpirationTimeInSeconds,
107	});
108	}
109
110	async deleteCounterfactualSafe(args: {
111	account: Account;
112	chainId: string;
113	predictedAddress: `0x${string}`;
114	}): Promise<void> {
115	try {	×
116	const { count } = await this	×
117	.sql`DELETE FROM counterfactual_safes WHERE chain_id = ${args.chainId} AND predicted_address = ${args.predictedAddress} AND account_id = ${args.account.id}`;
118	if (count === 0) {	×
119	this.loggingService.debug(	×
120	`Error deleting Counterfactual Safe (${args.chainId}, ${args.predictedAddress}): not found`,
121	);
122	}
123	} finally {
124	await Promise.all([	×
125	this.cacheService.deleteByKey(
126	CacheRouter.getCounterfactualSafeCacheDir(
127	args.chainId,
128	args.predictedAddress,
129	).key,
130	),
131	this.cacheService.deleteByKey(
132	CacheRouter.getCounterfactualSafesCacheDir(args.account.address).key,
133	),
134	]);
135	}
136	}
137
138	async deleteCounterfactualSafesForAccount(account: Account): Promise<void> {
139	let deleted: CounterfactualSafe[] = [];	×
140	try {	×
141	const rows = await this.sql<	×
142	CounterfactualSafe[]
143	>`DELETE FROM counterfactual_safes WHERE account_id = ${account.id} RETURNING *`;
144	deleted = rows;	×
145	} finally {
146	await this.cacheService.deleteByKey(	×
147	CacheRouter.getCounterfactualSafesCacheDir(account.address).key,
148	);
149	await Promise.all(	×
150	deleted.map((row) => {
151	return this.cacheService.deleteByKey(	×
152	CacheRouter.getCounterfactualSafeCacheDir(
153	row.chain_id,
154	row.predicted_address,
155	).key,
156	);
157	}),
158	);
159	}
160	}
161
162	private async checkCreationRateLimit(account: Account): Promise<void> {
163	const current = await this.cacheService.increment(	×
164	CacheRouter.getRateLimitCacheKey(
165	`${CounterfactualSafesDatasource.COUNTERFACTUAL_SAFES_CREATION_CACHE_PREFIX}_${account.address}`,
166	),
167	this.counterfactualSafesCreationRateLimitPeriodSeconds,
168	);
169	if (current > this.counterfactualSafesCreationRateLimitCalls) {	×
170	this.loggingService.warn(	×
171	`Limit of ${this.counterfactualSafesCreationRateLimitCalls} reached for account ${account.address}`,
172	);
173	throw new LimitReachedError();	×
174	}
175	}
176
177	private mapCreationDtoToRow(
178	account: Account,
179	createCounterfactualSafeDto: CreateCounterfactualSafeDto,
180	): Partial<CounterfactualSafe> {
181	return {	×
182	account_id: account.id,
183	chain_id: createCounterfactualSafeDto.chainId,
184	creator: account.address,
185	fallback_handler: createCounterfactualSafeDto.fallbackHandler,
186	owners: createCounterfactualSafeDto.owners,
187	predicted_address: createCounterfactualSafeDto.predictedAddress,
188	salt_nonce: createCounterfactualSafeDto.saltNonce,
189	singleton_address: createCounterfactualSafeDto.singletonAddress,
190	threshold: createCounterfactualSafeDto.threshold,
191	};
192	}
193	}

safe-global / safe-client-gateway / 10556232829

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