10701615083

Committed 04 Sep 2024 12:26PM UTC coverage: 46.305% (-0.01%) from 46.315%

Build # 10701615083

Build Type

Pull #1897

github

Committed by

hectorgomezv

Commit Message

Add KilnApi caching

Pull Request Pull Request #1897: Add KilnApi caching

Run Details

502 of 3103 branches covered (16.18%)

Branch coverage included in aggregate %.

11 of 35 new or added lines in 4 files covered. (31.43%)

65 existing lines in 2 files now uncovered.

4818 of 8386 relevant lines covered (57.45%)

12.24 hits per line

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

57.39

/src/datasources/cache/cache.router.ts

import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';

export class CacheRouter {
  private static readonly ACCOUNT_DATA_SETTINGS_KEY = 'account_data_settings';
  private static readonly ACCOUNT_DATA_TYPES_KEY = 'account_data_types';
  private static readonly ACCOUNT_KEY = 'account';
  private static readonly ALL_TRANSACTIONS_KEY = 'all_transactions';
  private static readonly AUTH_NONCE_KEY = 'auth_nonce';
  private static readonly BACKBONE_KEY = 'backbone';
  private static readonly CHAIN_KEY = 'chain';
  private static readonly CHAINS_KEY = 'chains';
  private static readonly CONTRACT_KEY = 'contract';
  private static readonly COUNTERFACTUAL_SAFE_KEY = 'counterfactual_safe';
  private static readonly COUNTERFACTUAL_SAFES_KEY = 'counterfactual_safes';
  private static readonly CREATION_TRANSACTION_KEY = 'creation_transaction';
  private static readonly DELEGATES_KEY = 'delegates';
  private static readonly FIREBASE_OAUTH2_TOKEN_KEY = 'firebase_oauth2_token';
  private static readonly INCOMING_TRANSFERS_KEY = 'incoming_transfers';
  private static readonly INDEXING_KEY = 'indexing';
  private static readonly MESSAGE_KEY = 'message';
  private static readonly MESSAGES_KEY = 'messages';
  private static readonly MODULE_TRANSACTION_KEY = 'module_transaction';
  private static readonly MODULE_TRANSACTIONS_KEY = 'module_transactions';
  private static readonly MULTISIG_TRANSACTION_KEY = 'multisig_transaction';
  private static readonly MULTISIG_TRANSACTIONS_KEY = 'multisig_transactions';
  private static readonly NATIVE_COIN_PRICE_KEY = 'native_coin_price';
  private static readonly OWNERS_SAFE_KEY = 'owner_safes';
  private static readonly RATE_LIMIT_KEY = 'rate_limit';
  private static readonly RELAY_KEY = 'relay';
  private static readonly RPC_REQUESTS_KEY = 'rpc_requests';
  private static readonly SAFE_APPS_KEY = 'safe_apps';
  private static readonly SAFE_BALANCES_KEY = 'safe_balances';
  private static readonly SAFE_COLLECTIBLES_KEY = 'safe_collectibles';
  private static readonly SAFE_EXISTS_KEY = 'safe_exists';
  private static readonly SAFE_FIAT_CODES_KEY = 'safe_fiat_codes';
  private static readonly SAFE_KEY = 'safe';
  private static readonly SINGLETONS_KEY = 'singletons';
  private static readonly STAKING_DEDICATED_STAKING_STATS_KEY =
    'staking_dedicated_staking_stats';
  private static readonly STAKING_DEFI_VAULT_STATS_KEY =
    'staking_defi_vault_stats';
  private static readonly STAKING_DEPLOYMENTS_KEY = 'staking_deployments';
  private static readonly STAKING_NETWORK_STATS_KEY = 'staking_network_stats';
  private static readonly STAKING_POOLED_STAKING_STATS_KEY =
    'staking_pooled_staking_stats';
  private static readonly TOKEN_KEY = 'token';
  private static readonly TOKEN_PRICE_KEY = 'token_price';
  private static readonly TOKENS_KEY = 'tokens';
  private static readonly TRANSFER_KEY = 'transfer';
  private static readonly TRANSFERS_KEY = 'transfers';
  private static readonly ZERION_BALANCES_KEY = 'zerion_balances';
  private static readonly ZERION_COLLECTIBLES_KEY = 'zerion_collectibles';

  static getAuthNonceCacheKey(nonce: string): string {
    return `${CacheRouter.AUTH_NONCE_KEY}_${nonce}`;
  }

  static getAuthNonceCacheDir(nonce: string): CacheDir {
    return new CacheDir(CacheRouter.getAuthNonceCacheKey(nonce), '');
  }

  static getBalancesCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.SAFE_BALANCES_KEY}_${args.safeAddress}`;
  }

  static getBalancesCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getBalancesCacheKey(args),
      `${args.trusted}_${args.excludeSpam}`,
    );
  }

  static getZerionBalancesCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.ZERION_BALANCES_KEY}_${args.safeAddress}`;
  }

  static getZerionBalancesCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    fiatCode: string;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getZerionBalancesCacheKey(args),
      args.fiatCode,
    );
  }

  static getZerionCollectiblesCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.ZERION_COLLECTIBLES_KEY}_${args.safeAddress}`;
  }

  static getZerionCollectiblesCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getZerionCollectiblesCacheKey(args),
      `${args.limit}_${args.offset}`,
    );
  }

  static getRateLimitCacheKey(prefix: string): string {
    return `${prefix}_${CacheRouter.RATE_LIMIT_KEY}`;
  }

  static getSafeCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(CacheRouter.getSafeCacheKey(args), '');
  }

  static getSafeCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.SAFE_KEY}_${args.safeAddress}`;
  }

  static getIsSafeCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(CacheRouter.getIsSafeCacheKey(args), '');
  }

  static getIsSafeCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.SAFE_EXISTS_KEY}_${args.safeAddress}`;
  }

  static getContractCacheDir(args: {
    chainId: string;
    contractAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.CONTRACT_KEY}_${args.contractAddress}`,
      '',
    );
  }

  static getBackboneCacheDir(chainId: string): CacheDir {
    return new CacheDir(`${chainId}_${CacheRouter.BACKBONE_KEY}`, '');
  }

  static getSingletonsCacheDir(chainId: string): CacheDir {
    return new CacheDir(`${chainId}_${CacheRouter.SINGLETONS_KEY}`, '');
  }

  static getCollectiblesCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getCollectiblesKey(args),
      `${args.limit}_${args.offset}_${args.trusted}_${args.excludeSpam}`,
    );
  }

  static getCollectiblesKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.SAFE_COLLECTIBLES_KEY}_${args.safeAddress}`;
  }

  static getDelegatesCacheDir(args: {
    chainId: string;
    safeAddress?: `0x${string}`;
    delegate?: `0x${string}`;
    delegator?: `0x${string}`;
    label?: string;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.DELEGATES_KEY}_${args.safeAddress}`,
      `${args.delegate}_${args.delegator}_${args.label}_${args.limit}_${args.offset}`,
    );
  }

  static getFirebaseOAuth2TokenCacheDir(): CacheDir {
    return new CacheDir(CacheRouter.FIREBASE_OAUTH2_TOKEN_KEY, '');
  }

  static getTransferCacheDir(args: {
    chainId: string;
    transferId: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.TRANSFER_KEY}_${args.transferId}`,
      '',
    );
  }

  static getTransfersCacheDir(args: {
    chainId: string;
    safeAddress: string;
    onlyErc20: boolean;
    onlyErc721: boolean;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getTransfersCacheKey(args),
      `${args.onlyErc20}_${args.onlyErc721}_${args.limit}_${args.offset}`,
    );
  }

  static getTransfersCacheKey(args: {
    chainId: string;
    safeAddress: string;
  }): string {
    return `${args.chainId}_${CacheRouter.TRANSFERS_KEY}_${args.safeAddress}`;
  }

  static getModuleTransactionCacheDir(args: {
    chainId: string;
    moduleTransactionId: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.MODULE_TRANSACTION_KEY}_${args.moduleTransactionId}`,
      '',
    );
  }

  static getModuleTransactionsCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    to?: string;
    txHash?: string;
    module?: string;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getModuleTransactionsCacheKey(args),
      `${args.to}_${args.module}_${args.txHash}_${args.limit}_${args.offset}`,
    );
  }

  static getModuleTransactionsCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.MODULE_TRANSACTIONS_KEY}_${args.safeAddress}`;
  }

  static getIncomingTransfersCacheDir(args: {
    chainId: string;
    safeAddress: string;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    tokenAddress?: string;
    txHash?: string;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getIncomingTransfersCacheKey(args),
      `${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.tokenAddress}_${args.txHash}_${args.limit}_${args.offset}`,
    );
  }

  static getIncomingTransfersCacheKey(args: {
    chainId: string;
    safeAddress: string;
  }): string {
    return `${args.chainId}_${CacheRouter.INCOMING_TRANSFERS_KEY}_${args.safeAddress}`;
  }

  static getIndexingCacheDir(chainId: string): CacheDir {
    return new CacheDir(`${chainId}_${CacheRouter.INDEXING_KEY}`, '');
  }

  static getMultisigTransactionsCacheDir(args: {
    chainId: string;
    safeAddress: string;
    ordering?: string;
    executed?: boolean;
    trusted?: boolean;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    nonce?: string;
    nonceGte?: number;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getMultisigTransactionsCacheKey(args),
      `${args.ordering}_${args.executed}_${args.trusted}_${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.nonce}_${args.nonceGte}_${args.limit}_${args.offset}`,
    );
  }

  static getMultisigTransactionsCacheKey(args: {
    chainId: string;
    safeAddress: string;
  }): string {
    return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTIONS_KEY}_${args.safeAddress}`;
  }

  static getMultisigTransactionCacheDir(args: {
    chainId: string;
    safeTransactionHash: string;
  }): CacheDir {
    return new CacheDir(CacheRouter.getMultisigTransactionCacheKey(args), '');
  }

  static getMultisigTransactionCacheKey(args: {
    chainId: string;
    safeTransactionHash: string;
  }): string {
    return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTION_KEY}_${args.safeTransactionHash}`;
  }

  static getCreationTransactionCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.CREATION_TRANSACTION_KEY}_${args.safeAddress}`,
      '',
    );
  }

  static getAllTransactionsCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    ordering?: string;
    executed?: boolean;
    queued?: boolean;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getAllTransactionsKey(args),
      `${args.ordering}_${args.executed}_${args.queued}_${args.limit}_${args.offset}`,
    );
  }

  static getAllTransactionsKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.ALL_TRANSACTIONS_KEY}_${args.safeAddress}`;
  }

  static getTokenCacheDir(args: {
    chainId: string;
    address: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.TOKEN_KEY}_${args.address}`,
      '',
    );
  }

  static getTokensCacheKey(chainId: string): string {
    return `${chainId}_${CacheRouter.TOKENS_KEY}`;
  }

  static getTokensCacheDir(args: {
    chainId: string;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getTokensCacheKey(args.chainId),
      `${args.limit}_${args.offset}`,
    );
  }

  static getSafesByOwnerCacheDir(args: {
    chainId: string;
    ownerAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.OWNERS_SAFE_KEY}_${args.ownerAddress}`,
      '',
    );
  }

  static getMessageByHashCacheKey(args: {
    chainId: string;
    messageHash: string;
  }): string {
    return `${args.chainId}_${CacheRouter.MESSAGE_KEY}_${args.messageHash}`;
  }

  static getMessageByHashCacheDir(args: {
    chainId: string;
    messageHash: string;
  }): CacheDir {
    return new CacheDir(this.getMessageByHashCacheKey(args), '');
  }

  static getMessagesBySafeCacheKey(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.MESSAGES_KEY}_${args.safeAddress}`;
  }

  static getMessagesBySafeCacheDir(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      this.getMessagesBySafeCacheKey(args),
      `${args.limit}_${args.offset}`,
    );
  }

  static getChainsCacheKey(): string {
    return CacheRouter.CHAINS_KEY;
  }

  static getChainsCacheDir(args: {
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getChainsCacheKey(),
      `${args.limit}_${args.offset}`,
    );
  }

  static getChainCacheKey(chainId: string): string {
    return `${chainId}_${CacheRouter.CHAIN_KEY}`;
  }

  static getChainCacheDir(chainId: string): CacheDir {
    return new CacheDir(CacheRouter.getChainCacheKey(chainId), '');
  }

  static getRelayKey(args: {
    chainId: string;
    address: `0x${string}`;
  }): string {
    return `${args.chainId}_${CacheRouter.RELAY_KEY}_${args.address}`;
  }

  static getRelayCacheDir(args: {
    chainId: string;
    address: `0x${string}`;
  }): CacheDir {
    return new CacheDir(CacheRouter.getRelayKey(args), '');
  }

  static getSafeAppsKey(chainId: string): string {
    return `${chainId}_${CacheRouter.SAFE_APPS_KEY}`;
  }

  static getSafeAppsCacheDir(args: {
    chainId?: string;
    clientUrl?: string;
    onlyListed?: boolean;
    url?: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.SAFE_APPS_KEY}`,
      `${args.clientUrl}_${args.onlyListed}_${args.url}`,
    );
  }

  static getNativeCoinPriceCacheDir(args: {
    nativeCoinId: string;
    fiatCode: string;
  }): CacheDir {
    return new CacheDir(
      `${args.nativeCoinId}_${CacheRouter.NATIVE_COIN_PRICE_KEY}_${args.fiatCode}`,
      '',
    );
  }

  static getTokenPriceCacheDir(args: {
    chainName: string;
    fiatCode: string;
    tokenAddress: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainName}_${CacheRouter.TOKEN_PRICE_KEY}_${args.tokenAddress}_${args.fiatCode}`,
      '',
    );
  }

  static getPriceFiatCodesCacheDir(): CacheDir {
    return new CacheDir(CacheRouter.SAFE_FIAT_CODES_KEY, '');
  }

  static getAccountCacheDir(address: `0x${string}`): CacheDir {
    return new CacheDir(`${CacheRouter.ACCOUNT_KEY}_${address}`, '');
  }

  static getAccountDataTypesCacheDir(): CacheDir {
    return new CacheDir(CacheRouter.ACCOUNT_DATA_TYPES_KEY, '');
  }

  static getAccountDataSettingsCacheDir(address: `0x${string}`): CacheDir {
    return new CacheDir(
      `${CacheRouter.ACCOUNT_DATA_SETTINGS_KEY}_${address}`,
      '',
    );
  }

  static getCounterfactualSafeCacheDir(
    chainId: string,
    predictedAddress: `0x${string}`,
  ): CacheDir {
    return new CacheDir(
      `${chainId}_${CacheRouter.COUNTERFACTUAL_SAFE_KEY}_${predictedAddress}`,
      '',
    );
  }

  static getCounterfactualSafesCacheDir(address: `0x${string}`): CacheDir {
    return new CacheDir(
      `${CacheRouter.COUNTERFACTUAL_SAFES_KEY}_${address}`,
      '',
    );
  }

  static getRpcRequestsKey(chainId: string): string {
    return `${chainId}_${CacheRouter.RPC_REQUESTS_KEY}`;
  }

  static getRpcRequestsCacheDir(args: {
    chainId: string;
    method: string;
    params: string;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getRpcRequestsKey(args.chainId),
      `${args.method}_${args.params}`,
    );
  }

  static getStakingDeploymentsCacheDir(): CacheDir {
    return new CacheDir(this.STAKING_DEPLOYMENTS_KEY, '');
  }

  static getStakingNetworkStatsCacheDir(): CacheDir {
    return new CacheDir(this.STAKING_NETWORK_STATS_KEY, '');
  }

  static getStakingDedicatedStakingStatsCacheDir(): CacheDir {
    return new CacheDir(this.STAKING_DEDICATED_STAKING_STATS_KEY, '');
  }

  static getStakingPooledStakingStatsCacheDir(pool: `0x${string}`): CacheDir {
    return new CacheDir(`${this.STAKING_POOLED_STAKING_STATS_KEY}_${pool}`, '');
  }

  static getStakingDefiVaultStatsCacheDir(args: {
    chainId: string;
    vault: `0x${string}`;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${this.STAKING_DEFI_VAULT_STATS_KEY}_${args.vault}`,
      '',
    );
  }
}

1	import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';	16✔
2
3	export class CacheRouter {	16✔
4	private static readonly ACCOUNT_DATA_SETTINGS_KEY = 'account_data_settings';	16✔
5	private static readonly ACCOUNT_DATA_TYPES_KEY = 'account_data_types';	16✔
6	private static readonly ACCOUNT_KEY = 'account';	16✔
7	private static readonly ALL_TRANSACTIONS_KEY = 'all_transactions';	16✔
8	private static readonly AUTH_NONCE_KEY = 'auth_nonce';	16✔
9	private static readonly BACKBONE_KEY = 'backbone';	16✔
10	private static readonly CHAIN_KEY = 'chain';	16✔
11	private static readonly CHAINS_KEY = 'chains';	16✔
12	private static readonly CONTRACT_KEY = 'contract';	16✔
13	private static readonly COUNTERFACTUAL_SAFE_KEY = 'counterfactual_safe';	16✔
14	private static readonly COUNTERFACTUAL_SAFES_KEY = 'counterfactual_safes';	16✔
15	private static readonly CREATION_TRANSACTION_KEY = 'creation_transaction';	16✔
16	private static readonly DELEGATES_KEY = 'delegates';	16✔
17	private static readonly FIREBASE_OAUTH2_TOKEN_KEY = 'firebase_oauth2_token';	16✔
18	private static readonly INCOMING_TRANSFERS_KEY = 'incoming_transfers';	16✔
19	private static readonly INDEXING_KEY = 'indexing';	16✔
20	private static readonly MESSAGE_KEY = 'message';	16✔
21	private static readonly MESSAGES_KEY = 'messages';	16✔
22	private static readonly MODULE_TRANSACTION_KEY = 'module_transaction';	16✔
23	private static readonly MODULE_TRANSACTIONS_KEY = 'module_transactions';	16✔
24	private static readonly MULTISIG_TRANSACTION_KEY = 'multisig_transaction';	16✔
25	private static readonly MULTISIG_TRANSACTIONS_KEY = 'multisig_transactions';	16✔
26	private static readonly NATIVE_COIN_PRICE_KEY = 'native_coin_price';	16✔
27	private static readonly OWNERS_SAFE_KEY = 'owner_safes';	16✔
28	private static readonly RATE_LIMIT_KEY = 'rate_limit';	16✔
29	private static readonly RELAY_KEY = 'relay';	16✔
30	private static readonly RPC_REQUESTS_KEY = 'rpc_requests';	16✔
31	private static readonly SAFE_APPS_KEY = 'safe_apps';	16✔
32	private static readonly SAFE_BALANCES_KEY = 'safe_balances';	16✔
33	private static readonly SAFE_COLLECTIBLES_KEY = 'safe_collectibles';	16✔
34	private static readonly SAFE_EXISTS_KEY = 'safe_exists';	16✔
35	private static readonly SAFE_FIAT_CODES_KEY = 'safe_fiat_codes';	16✔
36	private static readonly SAFE_KEY = 'safe';	16✔
37	private static readonly SINGLETONS_KEY = 'singletons';	16✔
38	private static readonly STAKING_DEDICATED_STAKING_STATS_KEY =	16✔
39	'staking_dedicated_staking_stats';
40	private static readonly STAKING_DEFI_VAULT_STATS_KEY =	16✔
41	'staking_defi_vault_stats';
42	private static readonly STAKING_DEPLOYMENTS_KEY = 'staking_deployments';	16✔
43	private static readonly STAKING_NETWORK_STATS_KEY = 'staking_network_stats';	16✔
44	private static readonly STAKING_POOLED_STAKING_STATS_KEY =	16✔
45	'staking_pooled_staking_stats';
46	private static readonly TOKEN_KEY = 'token';	16✔
47	private static readonly TOKEN_PRICE_KEY = 'token_price';	16✔
48	private static readonly TOKENS_KEY = 'tokens';	16✔
49	private static readonly TRANSFER_KEY = 'transfer';	16✔
50	private static readonly TRANSFERS_KEY = 'transfers';	16✔
51	private static readonly ZERION_BALANCES_KEY = 'zerion_balances';	16✔
52	private static readonly ZERION_COLLECTIBLES_KEY = 'zerion_collectibles';	16✔
53
54	static getAuthNonceCacheKey(nonce: string): string {
UNCOV 55	return `${CacheRouter.AUTH_NONCE_KEY}_${nonce}`;	×
56	}
57
58	static getAuthNonceCacheDir(nonce: string): CacheDir {
UNCOV 59	return new CacheDir(CacheRouter.getAuthNonceCacheKey(nonce), '');	×
60	}
61
62	static getBalancesCacheKey(args: {
63	chainId: string;
64	safeAddress: `0x${string}`;
65	}): string {
66	return `${args.chainId}_${CacheRouter.SAFE_BALANCES_KEY}_${args.safeAddress}`;	28✔
67	}
68
69	static getBalancesCacheDir(args: {
70	chainId: string;
71	safeAddress: `0x${string}`;
72	trusted?: boolean;
73	excludeSpam?: boolean;
74	}): CacheDir {
UNCOV 75	return new CacheDir(	×
76	CacheRouter.getBalancesCacheKey(args),
77	`${args.trusted}_${args.excludeSpam}`,
78	);
79	}
80
81	static getZerionBalancesCacheKey(args: {
82	chainId: string;
83	safeAddress: `0x${string}`;
84	}): string {
UNCOV 85	return `${args.chainId}_${CacheRouter.ZERION_BALANCES_KEY}_${args.safeAddress}`;	×
86	}
87
88	static getZerionBalancesCacheDir(args: {
89	chainId: string;
90	safeAddress: `0x${string}`;
91	fiatCode: string;
92	}): CacheDir {
UNCOV 93	return new CacheDir(	×
94	CacheRouter.getZerionBalancesCacheKey(args),
95	args.fiatCode,
96	);
97	}
98
99	static getZerionCollectiblesCacheKey(args: {
100	chainId: string;
101	safeAddress: `0x${string}`;
102	}): string {
UNCOV 103	return `${args.chainId}_${CacheRouter.ZERION_COLLECTIBLES_KEY}_${args.safeAddress}`;	×
104	}
105
106	static getZerionCollectiblesCacheDir(args: {
107	chainId: string;
108	safeAddress: `0x${string}`;
109	limit?: number;
110	offset?: number;
111	}): CacheDir {
UNCOV 112	return new CacheDir(	×
113	CacheRouter.getZerionCollectiblesCacheKey(args),
114	`${args.limit}_${args.offset}`,
115	);
116	}
117
118	static getRateLimitCacheKey(prefix: string): string {
UNCOV 119	return `${prefix}_${CacheRouter.RATE_LIMIT_KEY}`;	×
120	}
121
122	static getSafeCacheDir(args: {
123	chainId: string;
124	safeAddress: `0x${string}`;
125	}): CacheDir {
UNCOV 126	return new CacheDir(CacheRouter.getSafeCacheKey(args), '');	×
127	}
128
129	static getSafeCacheKey(args: {
130	chainId: string;
131	safeAddress: `0x${string}`;
132	}): string {
133	return `${args.chainId}_${CacheRouter.SAFE_KEY}_${args.safeAddress}`;	18✔
134	}
135
136	static getIsSafeCacheDir(args: {
137	chainId: string;
138	safeAddress: `0x${string}`;
139	}): CacheDir {
UNCOV 140	return new CacheDir(CacheRouter.getIsSafeCacheKey(args), '');	×
141	}
142
143	static getIsSafeCacheKey(args: {
144	chainId: string;
145	safeAddress: `0x${string}`;
146	}): string {
UNCOV 147	return `${args.chainId}_${CacheRouter.SAFE_EXISTS_KEY}_${args.safeAddress}`;	×
148	}
149
150	static getContractCacheDir(args: {
151	chainId: string;
152	contractAddress: `0x${string}`;
153	}): CacheDir {
154	return new CacheDir(	2✔
155	`${args.chainId}_${CacheRouter.CONTRACT_KEY}_${args.contractAddress}`,
156	'',
157	);
158	}
159
160	static getBackboneCacheDir(chainId: string): CacheDir {
UNCOV 161	return new CacheDir(`${chainId}_${CacheRouter.BACKBONE_KEY}`, '');	×
162	}
163
164	static getSingletonsCacheDir(chainId: string): CacheDir {
UNCOV 165	return new CacheDir(`${chainId}_${CacheRouter.SINGLETONS_KEY}`, '');	×
166	}
167
168	static getCollectiblesCacheDir(args: {
169	chainId: string;
170	safeAddress: `0x${string}`;
171	limit?: number;
172	offset?: number;
173	trusted?: boolean;
174	excludeSpam?: boolean;
175	}): CacheDir {
UNCOV 176	return new CacheDir(	×
177	CacheRouter.getCollectiblesKey(args),
178	`${args.limit}_${args.offset}_${args.trusted}_${args.excludeSpam}`,
179	);
180	}
181
182	static getCollectiblesKey(args: {
183	chainId: string;
184	safeAddress: `0x${string}`;
185	}): string {
186	return `${args.chainId}_${CacheRouter.SAFE_COLLECTIBLES_KEY}_${args.safeAddress}`;	30✔
187	}
188
189	static getDelegatesCacheDir(args: {
190	chainId: string;
191	safeAddress?: `0x${string}`;
192	delegate?: `0x${string}`;
193	delegator?: `0x${string}`;
194	label?: string;
195	limit?: number;
196	offset?: number;
197	}): CacheDir {
UNCOV 198	return new CacheDir(	×
199	`${args.chainId}_${CacheRouter.DELEGATES_KEY}_${args.safeAddress}`,
200	`${args.delegate}_${args.delegator}_${args.label}_${args.limit}_${args.offset}`,
201	);
202	}
203
204	static getFirebaseOAuth2TokenCacheDir(): CacheDir {
UNCOV 205	return new CacheDir(CacheRouter.FIREBASE_OAUTH2_TOKEN_KEY, '');	×
206	}
207
208	static getTransferCacheDir(args: {
209	chainId: string;
210	transferId: string;
211	}): CacheDir {
UNCOV 212	return new CacheDir(	×
213	`${args.chainId}_${CacheRouter.TRANSFER_KEY}_${args.transferId}`,
214	'',
215	);
216	}
217
218	static getTransfersCacheDir(args: {
219	chainId: string;
220	safeAddress: string;
221	onlyErc20: boolean;
222	onlyErc721: boolean;
223	limit?: number;
224	offset?: number;
225	}): CacheDir {
UNCOV 226	return new CacheDir(	×
227	CacheRouter.getTransfersCacheKey(args),
228	`${args.onlyErc20}_${args.onlyErc721}_${args.limit}_${args.offset}`,
229	);
230	}
231
232	static getTransfersCacheKey(args: {
233	chainId: string;
234	safeAddress: string;
235	}): string {
236	return `${args.chainId}_${CacheRouter.TRANSFERS_KEY}_${args.safeAddress}`;	40✔
237	}
238
239	static getModuleTransactionCacheDir(args: {
240	chainId: string;
241	moduleTransactionId: string;
242	}): CacheDir {
UNCOV 243	return new CacheDir(	×
244	`${args.chainId}_${CacheRouter.MODULE_TRANSACTION_KEY}_${args.moduleTransactionId}`,
245	'',
246	);
247	}
248
249	static getModuleTransactionsCacheDir(args: {
250	chainId: string;
251	safeAddress: `0x${string}`;
252	to?: string;
253	txHash?: string;
254	module?: string;
255	limit?: number;
256	offset?: number;
257	}): CacheDir {
UNCOV 258	return new CacheDir(	×
259	CacheRouter.getModuleTransactionsCacheKey(args),
260	`${args.to}_${args.module}_${args.txHash}_${args.limit}_${args.offset}`,
261	);
262	}
263
264	static getModuleTransactionsCacheKey(args: {
265	chainId: string;
266	safeAddress: `0x${string}`;
267	}): string {
268	return `${args.chainId}_${CacheRouter.MODULE_TRANSACTIONS_KEY}_${args.safeAddress}`;	6✔
269	}
270
271	static getIncomingTransfersCacheDir(args: {
272	chainId: string;
273	safeAddress: string;
274	executionDateGte?: string;
275	executionDateLte?: string;
276	to?: string;
277	value?: string;
278	tokenAddress?: string;
279	txHash?: string;
280	limit?: number;
281	offset?: number;
282	}): CacheDir {
UNCOV 283	return new CacheDir(	×
284	CacheRouter.getIncomingTransfersCacheKey(args),
285	`${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.tokenAddress}_${args.txHash}_${args.limit}_${args.offset}`,
286	);
287	}
288
289	static getIncomingTransfersCacheKey(args: {
290	chainId: string;
291	safeAddress: string;
292	}): string {
293	return `${args.chainId}_${CacheRouter.INCOMING_TRANSFERS_KEY}_${args.safeAddress}`;	16✔
294	}
295
296	static getIndexingCacheDir(chainId: string): CacheDir {
UNCOV 297	return new CacheDir(`${chainId}_${CacheRouter.INDEXING_KEY}`, '');	×
298	}
299
300	static getMultisigTransactionsCacheDir(args: {
301	chainId: string;
302	safeAddress: string;
303	ordering?: string;
304	executed?: boolean;
305	trusted?: boolean;
306	executionDateGte?: string;
307	executionDateLte?: string;
308	to?: string;
309	value?: string;
310	nonce?: string;
311	nonceGte?: number;
312	limit?: number;
313	offset?: number;
314	}): CacheDir {
UNCOV 315	return new CacheDir(	×
316	CacheRouter.getMultisigTransactionsCacheKey(args),
317	`${args.ordering}_${args.executed}_${args.trusted}_${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.nonce}_${args.nonceGte}_${args.limit}_${args.offset}`,
318	);
319	}
320
321	static getMultisigTransactionsCacheKey(args: {
322	chainId: string;
323	safeAddress: string;
324	}): string {
325	return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTIONS_KEY}_${args.safeAddress}`;	52✔
326	}
327
328	static getMultisigTransactionCacheDir(args: {
329	chainId: string;
330	safeTransactionHash: string;
331	}): CacheDir {
UNCOV 332	return new CacheDir(CacheRouter.getMultisigTransactionCacheKey(args), '');	×
333	}
334
335	static getMultisigTransactionCacheKey(args: {
336	chainId: string;
337	safeTransactionHash: string;
338	}): string {
339	return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTION_KEY}_${args.safeTransactionHash}`;	24✔
340	}
341
342	static getCreationTransactionCacheDir(args: {
343	chainId: string;
344	safeAddress: `0x${string}`;
345	}): CacheDir {
UNCOV 346	return new CacheDir(	×
347	`${args.chainId}_${CacheRouter.CREATION_TRANSACTION_KEY}_${args.safeAddress}`,
348	'',
349	);
350	}
351
352	static getAllTransactionsCacheDir(args: {
353	chainId: string;
354	safeAddress: `0x${string}`;
355	ordering?: string;
356	executed?: boolean;
357	queued?: boolean;
358	limit?: number;
359	offset?: number;
360	}): CacheDir {
UNCOV 361	return new CacheDir(	×
362	CacheRouter.getAllTransactionsKey(args),
363	`${args.ordering}_${args.executed}_${args.queued}_${args.limit}_${args.offset}`,
364	);
365	}
366
367	static getAllTransactionsKey(args: {
368	chainId: string;
369	safeAddress: `0x${string}`;
370	}): string {
371	return `${args.chainId}_${CacheRouter.ALL_TRANSACTIONS_KEY}_${args.safeAddress}`;	46✔
372	}
373
374	static getTokenCacheDir(args: {
375	chainId: string;
376	address: string;
377	}): CacheDir {
UNCOV 378	return new CacheDir(	×
379	`${args.chainId}_${CacheRouter.TOKEN_KEY}_${args.address}`,
380	'',
381	);
382	}
383
384	static getTokensCacheKey(chainId: string): string {
UNCOV 385	return `${chainId}_${CacheRouter.TOKENS_KEY}`;	×
386	}
387
388	static getTokensCacheDir(args: {
389	chainId: string;
390	limit?: number;
391	offset?: number;
392	}): CacheDir {
UNCOV 393	return new CacheDir(	×
394	CacheRouter.getTokensCacheKey(args.chainId),
395	`${args.limit}_${args.offset}`,
396	);
397	}
398
399	static getSafesByOwnerCacheDir(args: {
400	chainId: string;
401	ownerAddress: `0x${string}`;
402	}): CacheDir {
403	return new CacheDir(	2✔
404	`${args.chainId}_${CacheRouter.OWNERS_SAFE_KEY}_${args.ownerAddress}`,
405	'',
406	);
407	}
408
409	static getMessageByHashCacheKey(args: {
410	chainId: string;
411	messageHash: string;
412	}): string {
413	return `${args.chainId}_${CacheRouter.MESSAGE_KEY}_${args.messageHash}`;	2✔
414	}
415
416	static getMessageByHashCacheDir(args: {
417	chainId: string;
418	messageHash: string;
419	}): CacheDir {
UNCOV 420	return new CacheDir(this.getMessageByHashCacheKey(args), '');	×
421	}
422
423	static getMessagesBySafeCacheKey(args: {
424	chainId: string;
425	safeAddress: `0x${string}`;
426	}): string {
427	return `${args.chainId}_${CacheRouter.MESSAGES_KEY}_${args.safeAddress}`;	4✔
428	}
429
430	static getMessagesBySafeCacheDir(args: {
431	chainId: string;
432	safeAddress: `0x${string}`;
433	limit?: number;
434	offset?: number;
435	}): CacheDir {
UNCOV 436	return new CacheDir(	×
437	this.getMessagesBySafeCacheKey(args),
438	`${args.limit}_${args.offset}`,
439	);
440	}
441
442	static getChainsCacheKey(): string {
443	return CacheRouter.CHAINS_KEY;	2✔
444	}
445
446	static getChainsCacheDir(args: {
447	limit?: number;
448	offset?: number;
449	}): CacheDir {
UNCOV 450	return new CacheDir(	×
451	CacheRouter.getChainsCacheKey(),
452	`${args.limit}_${args.offset}`,
453	);
454	}
455
456	static getChainCacheKey(chainId: string): string {
457	return `${chainId}_${CacheRouter.CHAIN_KEY}`;	22✔
458	}
459
460	static getChainCacheDir(chainId: string): CacheDir {
461	return new CacheDir(CacheRouter.getChainCacheKey(chainId), '');	20✔
462	}
463
464	static getRelayKey(args: {
465	chainId: string;
466	address: `0x${string}`;
467	}): string {
UNCOV 468	return `${args.chainId}_${CacheRouter.RELAY_KEY}_${args.address}`;	×
469	}
470
471	static getRelayCacheDir(args: {
472	chainId: string;
473	address: `0x${string}`;
474	}): CacheDir {
UNCOV 475	return new CacheDir(CacheRouter.getRelayKey(args), '');	×
476	}
477
478	static getSafeAppsKey(chainId: string): string {
479	return `${chainId}_${CacheRouter.SAFE_APPS_KEY}`;	2✔
480	}
481
482	static getSafeAppsCacheDir(args: {
483	chainId?: string;
484	clientUrl?: string;
485	onlyListed?: boolean;
486	url?: string;
487	}): CacheDir {
488	return new CacheDir(	4✔
489	`${args.chainId}_${CacheRouter.SAFE_APPS_KEY}`,
490	`${args.clientUrl}_${args.onlyListed}_${args.url}`,
491	);
492	}
493
494	static getNativeCoinPriceCacheDir(args: {
495	nativeCoinId: string;
496	fiatCode: string;
497	}): CacheDir {
UNCOV 498	return new CacheDir(	×
499	`${args.nativeCoinId}_${CacheRouter.NATIVE_COIN_PRICE_KEY}_${args.fiatCode}`,
500	'',
501	);
502	}
503
504	static getTokenPriceCacheDir(args: {
505	chainName: string;
506	fiatCode: string;
507	tokenAddress: string;
508	}): CacheDir {
UNCOV 509	return new CacheDir(	×
510	`${args.chainName}_${CacheRouter.TOKEN_PRICE_KEY}_${args.tokenAddress}_${args.fiatCode}`,
511	'',
512	);
513	}
514
515	static getPriceFiatCodesCacheDir(): CacheDir {
UNCOV 516	return new CacheDir(CacheRouter.SAFE_FIAT_CODES_KEY, '');	×
517	}
518
519	static getAccountCacheDir(address: `0x${string}`): CacheDir {
UNCOV 520	return new CacheDir(`${CacheRouter.ACCOUNT_KEY}_${address}`, '');	×
521	}
522
523	static getAccountDataTypesCacheDir(): CacheDir {
UNCOV 524	return new CacheDir(CacheRouter.ACCOUNT_DATA_TYPES_KEY, '');	×
525	}
526
527	static getAccountDataSettingsCacheDir(address: `0x${string}`): CacheDir {
UNCOV 528	return new CacheDir(	×
529	`${CacheRouter.ACCOUNT_DATA_SETTINGS_KEY}_${address}`,
530	'',
531	);
532	}
533
534	static getCounterfactualSafeCacheDir(
535	chainId: string,
536	predictedAddress: `0x${string}`,
537	): CacheDir {
UNCOV 538	return new CacheDir(	×
539	`${chainId}_${CacheRouter.COUNTERFACTUAL_SAFE_KEY}_${predictedAddress}`,
540	'',
541	);
542	}
543
544	static getCounterfactualSafesCacheDir(address: `0x${string}`): CacheDir {
UNCOV 545	return new CacheDir(	×
546	`${CacheRouter.COUNTERFACTUAL_SAFES_KEY}_${address}`,
547	'',
548	);
549	}
550
551	static getRpcRequestsKey(chainId: string): string {
UNCOV 552	return `${chainId}_${CacheRouter.RPC_REQUESTS_KEY}`;	×
553	}
554
555	static getRpcRequestsCacheDir(args: {
556	chainId: string;
557	method: string;
558	params: string;
559	}): CacheDir {
UNCOV 560	return new CacheDir(	×
561	CacheRouter.getRpcRequestsKey(args.chainId),
562	`${args.method}_${args.params}`,
563	);
564	}
565
566	static getStakingDeploymentsCacheDir(): CacheDir {
NEW 567	return new CacheDir(this.STAKING_DEPLOYMENTS_KEY, '');	×
568	}
569
570	static getStakingNetworkStatsCacheDir(): CacheDir {
NEW 571	return new CacheDir(this.STAKING_NETWORK_STATS_KEY, '');	×
572	}
573
574	static getStakingDedicatedStakingStatsCacheDir(): CacheDir {
NEW 575	return new CacheDir(this.STAKING_DEDICATED_STAKING_STATS_KEY, '');	×
576	}
577
578	static getStakingPooledStakingStatsCacheDir(pool: `0x${string}`): CacheDir {
NEW 579	return new CacheDir(`${this.STAKING_POOLED_STAKING_STATS_KEY}_${pool}`, '');	×
580	}
581
582	static getStakingDefiVaultStatsCacheDir(args: {
583	chainId: string;
584	vault: `0x${string}`;
585	}): CacheDir {
NEW 586	return new CacheDir(	×
587	`${args.chainId}_${this.STAKING_DEFI_VAULT_STATS_KEY}_${args.vault}`,
588	'',
589	);
590	}
591	}

safe-global / safe-client-gateway / 10701615083

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