10404724557

Committed 15 Aug 2024 01:38PM UTC coverage: 46.856% (-0.09%) from 46.944%

Build # 10404724557

Build Type

push

github

Committed by

iamacook

Commit Message

Add caching layer to RPC requests

Run Details

480 of 2893 branches covered (16.59%)

Branch coverage included in aggregate %.

9 of 31 new or added lines in 2 files covered. (29.03%)

3 existing lines in 3 files now uncovered.

4558 of 7859 relevant lines covered (58.0%)

12.5 hits per line

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

37.1

/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];
  }

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

    delete this.blockchainApiMap[chainId];

    const key = CacheRouter.getRpcRequestsKey(chainId);
    await 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.get(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.set(
        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';	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 { Chain as DomainChain } from '@/domain/chains/entities/chain.entity';
8	import { RpcUriAuthentication } from '@/domain/chains/entities/rpc-uri-authentication.entity';	16✔
9	import { IBlockchainApiManager } from '@/domain/interfaces/blockchain-api.manager.interface';
10	import { IConfigApi } from '@/domain/interfaces/config-api.interface';	16✔
11	import { Inject, Injectable } from '@nestjs/common';	16✔
12	import {	16✔
13	Chain,
14	PublicClient,
15	RpcRequestError,
16	createPublicClient,
17	custom,
18	} from 'viem';
19	import { getHttpRpcClient } from 'viem/utils';	16✔
20
21	@Injectable()
22	export class BlockchainApiManager implements IBlockchainApiManager {	16✔
23	private static readonly INFURA_URL_PATTERN = 'infura';	16✔
24	private readonly blockchainApiMap: Record<string, PublicClient> = {};	16✔
25	private readonly infuraApiKey: string;
26	private readonly rpcExpirationTimeInSeconds: number;
27
28	constructor(
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	16✔
31	@Inject(IConfigApi) private readonly configApi: IConfigApi,	16✔
32	@Inject(CacheService) private readonly cacheService: ICacheService,	16✔
33	) {
34	this.infuraApiKey = this.configurationService.getOrThrow<string>(	16✔
35	'blockchain.infura.apiKey',
36	);
37	this.rpcExpirationTimeInSeconds =	16✔
38	this.configurationService.getOrThrow<number>(
39	'expirationTimeInSeconds.rpc',
40	);
41	}
42
43	async getApi(chainId: string): Promise<PublicClient> {
44	const blockchainApi = this.blockchainApiMap[chainId];	×
45	if (blockchainApi) {	×
46	return blockchainApi;	×
47	}
48
49	const chain = await this.configApi.getChain(chainId);	×
NEW 50	this.blockchainApiMap[chainId] = this._createCachedRpcClient(chain);	×
51
52	return this.blockchainApiMap[chainId];	×
53	}
54
55	async destroyApi(chainId: string): Promise<void> {
56	if (!this.blockchainApiMap?.[chainId]) {	2✔
57	return;	2✔
58	}
59
NEW 60	delete this.blockchainApiMap[chainId];	×
61
NEW 62	const key = CacheRouter.getRpcRequestsKey(chainId);	×
NEW 63	await this.cacheService.deleteByKey(key);	×
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 {
NEW 71	const chain = this.formatChain(domainChain);	×
72
NEW 73	const rpcUrl = chain.rpcUrls.default.http[0];	×
NEW 74	const rpcClient = getHttpRpcClient(rpcUrl);	×
75
NEW 76	const request = async (body: {	×
77	method: string;
78	params?: unknown;
79	}): Promise<unknown> => {
NEW 80	const cacheDir = CacheRouter.getRpcRequestsCacheDir({	×
81	chainId: domainChain.chainId,
82	method: body.method,
83	params: ((): string => {
NEW 84	try {	×
85	// We cannot be certain of the shape of the params object
NEW 86	return JSON.stringify(body.params);	×
87	} catch {
NEW 88	return '';	×
89	}
90	})(),
91	});
92
NEW 93	const cache = await this.cacheService.get(cacheDir);	×
94
NEW 95	if (cache != null) {	×
NEW 96	return JSON.parse(cache);	×
97	}
98
NEW 99	const { error, result } = await rpcClient.request({	×
100	body,
101	});
102
NEW 103	if (error) {	×
NEW 104	throw new RpcRequestError({	×
105	body,
106	error,
107	url: rpcUrl,
108	});
109	}
110
NEW 111	await this.cacheService.set(	×
112	cacheDir,
113	JSON.stringify(result),
114	this.rpcExpirationTimeInSeconds,
115	);
116
NEW 117	return result;	×
118	};
119
UNCOV 120	return createPublicClient({	×
121	chain,
122	transport: custom({
123	request,
124	}),
125	});
126	}
127
128	private formatChain(chain: DomainChain): Chain {
129	return {	×
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 &&	×
149	rpcUri.value.includes(BlockchainApiManager.INFURA_URL_PATTERN)
150	? rpcUri.value + this.infuraApiKey
151	: rpcUri.value;
152	}
153	}

safe-global / safe-client-gateway / 10404724557

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