11106406463

Committed 30 Sep 2024 12:46PM UTC coverage: 90.853% (-0.01%) from 90.863%

Build # 11106406463

Build Type

push

github

Committed by

web-flow

Commit Message

Don't assume all RPC responses are strings (#1967)

Adjusts RPC cache error handling logic to only throw if an error was returned by the RPC, not if the response if a string:

- Don't throw if RPC result is not a string.
- Add test coverage

Run Details

2549 of 3178 branches covered (80.21%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

8437 of 8914 relevant lines covered (94.65%)

445.34 hits per line

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

93.55

/src/datasources/blockchain/blockchain-api.manager.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 { Chain as DomainChain } from '@/domain/chains/entities/chain.entity';
import { RpcUriAuthentication } from '@/domain/chains/entities/rpc-uri-authentication.entity';
import { IBlockchainApiManager } from '@/domain/interfaces/blockchain-api.manager.interface';
import { IConfigApi } from '@/domain/interfaces/config-api.interface';
import { Inject, Injectable } from '@nestjs/common';
import {
  Chain,
  PublicClient,
  RpcRequestError,
  createPublicClient,
  custom,
} from 'viem';
import { getHttpRpcClient } from 'viem/utils';

@Injectable()
export class BlockchainApiManager implements IBlockchainApiManager {
  private static readonly INFURA_URL_PATTERN = 'infura';
  private readonly blockchainApiMap: Record<string, PublicClient> = {};
  private readonly infuraApiKey: string;
  private readonly rpcExpirationTimeInSeconds: number;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IConfigApi) private readonly configApi: IConfigApi,
    @Inject(CacheService) private readonly cacheService: ICacheService,
  ) {
    this.infuraApiKey = this.configurationService.getOrThrow<string>(
      'blockchain.infura.apiKey',
    );
    this.rpcExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.rpc',
      );
  }

  async getApi(chainId: string): Promise<PublicClient> {
    const blockchainApi = this.blockchainApiMap[chainId];
    if (blockchainApi) {
      return blockchainApi;
    }

    const chain = await this.configApi.getChain(chainId);
    this.blockchainApiMap[chainId] = this._createCachedRpcClient(chain);

    return this.blockchainApiMap[chainId];
  }

  destroyApi(chainId: string): void {
    if (!this.blockchainApiMap?.[chainId]) {
      return;
    }

    delete this.blockchainApiMap[chainId];

    const key = CacheRouter.getRpcRequestsKey(chainId);
    void this.cacheService.deleteByKey(key);
  }

  /**
   * Creates a {@link PublicClient} with a cache layer for RPC requests
   * @param domainChain {@link DomainChain} to create the client for
   */
  _createCachedRpcClient(domainChain: DomainChain): PublicClient {
    const chain = this.formatChain(domainChain);

    const rpcUrl = chain.rpcUrls.default.http[0];
    const rpcClient = getHttpRpcClient(rpcUrl);

    const request = async (body: {
      method: string;
      params?: unknown;
    }): Promise<unknown> => {
      const cacheDir = CacheRouter.getRpcRequestsCacheDir({
        chainId: domainChain.chainId,
        method: body.method,
        params: ((): string => {
          try {
            // We cannot be certain of the shape of the params object
            return JSON.stringify(body.params);
          } catch {
            return '';
          }
        })(),
      });

      const cache = await this.cacheService.hGet(cacheDir);

      if (cache != null) {
        return JSON.parse(cache);
      }

      const { error, result } = await rpcClient.request({
        body,
      });

      if (error) {
        throw new RpcRequestError({
          body,
          error,
          url: rpcUrl,
        });
      }

      await this.cacheService.hSet(
        cacheDir,
        JSON.stringify(result),
        this.rpcExpirationTimeInSeconds,
      );

      return result;
    };

    return createPublicClient({
      chain,
      transport: custom({
        request,
      }),
    });
  }

  private formatChain(chain: DomainChain): Chain {
    return {
      id: Number(chain.chainId),
      name: chain.chainName,
      nativeCurrency: chain.nativeCurrency,
      rpcUrls: {
        default: {
          http: [this.formatRpcUri(chain.rpcUri)],
        },
      },
    };
  }

  /**
   * Formats rpcUri to include the Infura API key if the rpcUri is an Infura URL
   * and the authentication method is {@link RpcUriAuthentication.ApiKeyPath}.
   * @param rpcUri rpcUri to format
   * @returns Formatted rpcUri
   */
  private formatRpcUri(rpcUri: DomainChain['rpcUri']): string {
    return rpcUri.authentication === RpcUriAuthentication.ApiKeyPath &&
      rpcUri.value.includes(BlockchainApiManager.INFURA_URL_PATTERN)
      ? rpcUri.value + this.infuraApiKey
      : rpcUri.value;
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	106✔
2	import { CacheRouter } from '@/datasources/cache/cache.router';	106✔
3	import {	106✔
4	CacheService,
5	ICacheService,
6	} from '@/datasources/cache/cache.service.interface';
7	import { Chain as DomainChain } from '@/domain/chains/entities/chain.entity';
8	import { RpcUriAuthentication } from '@/domain/chains/entities/rpc-uri-authentication.entity';	106✔
9	import { IBlockchainApiManager } from '@/domain/interfaces/blockchain-api.manager.interface';
10	import { IConfigApi } from '@/domain/interfaces/config-api.interface';	106✔
11	import { Inject, Injectable } from '@nestjs/common';	106✔
12	import {	106✔
13	Chain,
14	PublicClient,
15	RpcRequestError,
16	createPublicClient,
17	custom,
18	} from 'viem';
19	import { getHttpRpcClient } from 'viem/utils';	106✔
20
21	@Injectable()
22	export class BlockchainApiManager implements IBlockchainApiManager {	106✔
23	private static readonly INFURA_URL_PATTERN = 'infura';	106✔
24	private readonly blockchainApiMap: Record<string, PublicClient> = {};	1,536✔
25	private readonly infuraApiKey: string;
26	private readonly rpcExpirationTimeInSeconds: number;
27
28	constructor(
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	1,536✔
31	@Inject(IConfigApi) private readonly configApi: IConfigApi,	1,536✔
32	@Inject(CacheService) private readonly cacheService: ICacheService,	1,536✔
33	) {
34	this.infuraApiKey = this.configurationService.getOrThrow<string>(	1,536✔
35	'blockchain.infura.apiKey',
36	);
37	this.rpcExpirationTimeInSeconds =	1,536✔
38	this.configurationService.getOrThrow<number>(
39	'expirationTimeInSeconds.rpc',
40	);
41	}
42
43	async getApi(chainId: string): Promise<PublicClient> {
44	const blockchainApi = this.blockchainApiMap[chainId];	18✔
45	if (blockchainApi) {	18✔
46	return blockchainApi;	2✔
47	}
48
49	const chain = await this.configApi.getChain(chainId);	16✔
50	this.blockchainApiMap[chainId] = this._createCachedRpcClient(chain);	16✔
51
52	return this.blockchainApiMap[chainId];	16✔
53	}
54
55	destroyApi(chainId: string): void {
56	if (!this.blockchainApiMap?.[chainId]) {	20✔
57	return;	16✔
58	}
59
60	delete this.blockchainApiMap[chainId];	4✔
61
62	const key = CacheRouter.getRpcRequestsKey(chainId);	4✔
63	void this.cacheService.deleteByKey(key);	4✔
64	}
65
66	/**
67	* Creates a {@link PublicClient} with a cache layer for RPC requests
68	* @param domainChain {@link DomainChain} to create the client for
69	*/
70	_createCachedRpcClient(domainChain: DomainChain): PublicClient {
71	const chain = this.formatChain(domainChain);	20✔
72
73	const rpcUrl = chain.rpcUrls.default.http[0];	20✔
74	const rpcClient = getHttpRpcClient(rpcUrl);	20✔
75
76	const request = async (body: {	20✔
77	method: string;
78	params?: unknown;
79	}): Promise<unknown> => {
80	const cacheDir = CacheRouter.getRpcRequestsCacheDir({	12✔
81	chainId: domainChain.chainId,
82	method: body.method,
83	params: ((): string => {
84	try {	12✔
85	// We cannot be certain of the shape of the params object
86	return JSON.stringify(body.params);	12✔
87	} catch {
88	return '';	×
89	}
90	})(),
91	});
92
93	const cache = await this.cacheService.hGet(cacheDir);	12✔
94
95	if (cache != null) {	12✔
96	return JSON.parse(cache);	8✔
97	}
98
99	const { error, result } = await rpcClient.request({	4✔
100	body,
101	});
102
103	if (error) {	4!
UNCOV 104	throw new RpcRequestError({	×
105	body,
106	error,
107	url: rpcUrl,
108	});
109	}
110
111	await this.cacheService.hSet(	4✔
112	cacheDir,
113	JSON.stringify(result),
114	this.rpcExpirationTimeInSeconds,
115	);
116
117	return result;	4✔
118	};
119
120	return createPublicClient({	20✔
121	chain,
122	transport: custom({
123	request,
124	}),
125	});
126	}
127
128	private formatChain(chain: DomainChain): Chain {
129	return {	20✔
130	id: Number(chain.chainId),
131	name: chain.chainName,
132	nativeCurrency: chain.nativeCurrency,
133	rpcUrls: {
134	default: {
135	http: [this.formatRpcUri(chain.rpcUri)],
136	},
137	},
138	};
139	}
140
141	/**
142	* Formats rpcUri to include the Infura API key if the rpcUri is an Infura URL
143	* and the authentication method is {@link RpcUriAuthentication.ApiKeyPath}.
144	* @param rpcUri rpcUri to format
145	* @returns Formatted rpcUri
146	*/
147	private formatRpcUri(rpcUri: DomainChain['rpcUri']): string {
148	return rpcUri.authentication === RpcUriAuthentication.ApiKeyPath &&	20✔
149	rpcUri.value.includes(BlockchainApiManager.INFURA_URL_PATTERN)
150	? rpcUri.value + this.infuraApiKey
151	: rpcUri.value;
152	}
153	}

safe-global / safe-client-gateway / 11106406463

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