10270365227

Committed 06 Aug 2024 04:28PM UTC coverage: 48.014% (-0.01%) from 48.025%

Build # 10270365227

Build Type

Pull #1801

github

Committed by

web-flow

Commit Message

Fix Counterfactual Safes CacheDir (#1802)

Adds `accountId` to the arguments list for `CacheRouter.getCounterfactualSafeCacheDir`.

Pull Request Pull Request #1801: Implement Counterfactual Safes creation rate limit

Run Details

456 of 2724 branches covered (16.74%)

Branch coverage included in aggregate %.

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

3 existing lines in 2 files now uncovered.

4427 of 7446 relevant lines covered (59.45%)

12.89 hits per line

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

59.0

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

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

export class CacheRouter {
  private static readonly ACCOUNT_KEY = 'account';
  private static readonly ACCOUNT_DATA_SETTINGS_KEY = 'account_data_settings';
  private static readonly ACCOUNT_DATA_TYPES_KEY = 'account_data_types';
  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 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 RELAY_KEY = 'relay';
  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 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';
  private static readonly RATE_LIMIT_KEY = 'rate_limit';

  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;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getIncomingTransfersCacheKey(args),
      `${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.tokenAddress}_${args.limit}_${args.offset}`,
    );
  }

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

  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(args: {
    accountId: number;
    chainId: string;
    predictedAddress: `0x${string}`;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.COUNTERFACTUAL_SAFE_KEY}_${args.accountId}_${args.predictedAddress}`,
      '',
    );
  }

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

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

safe-global / safe-client-gateway / 10270365227

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