7932159520

Committed 16 Feb 2024 02:42PM UTC coverage: 93.011% (-0.9%) from 93.863%

Build # 7932159520

Build Type

Pull #1148

github

Committed by

iamacook

Commit Message

Merge branch 'safe-abis' into use-abiencoders

Pull Request Pull Request #1148: Replace Safe/ERC-20 `ContractHelper`s with `AbiDecoder`s

Run Details

1623 of 1944 branches covered (83.49%)

Branch coverage included in aggregate %.

19 of 22 new or added lines in 5 files covered. (86.36%)

72 existing lines in 11 files now uncovered.

5936 of 6183 relevant lines covered (96.01%)

177.62 hits per line

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

97.5

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

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

export class CacheRouter {
  private static readonly ALL_TRANSACTIONS_KEY = 'all_transactions';
  private static readonly BACKBONE_KEY = 'backbone';
  private static readonly BALANCES_KEY = 'balances';
  private static readonly CHAIN_KEY = 'chain';
  private static readonly CHAINS_KEY = 'chains';
  private static readonly COLLECTIBLES_KEY = 'collectibles';
  private static readonly CONTRACT_KEY = 'contract';
  private static readonly CREATION_TRANSACTION_KEY = 'creation_transaction';
  private static readonly DELEGATES_KEY = 'delegates';
  private static readonly FIAT_CODES_KEY = 'fiat_codes';
  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_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';

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

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

  // TODO: remove this prefixed key if eventually only one balances provider is used
  static getZerionBalancesCacheKey(args: {
    chainId: string;
    safeAddress: string;
  }): string {
    return `${args.chainId}_${CacheRouter.ZERION_BALANCES_KEY}_${args.safeAddress}`;
  }

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

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

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

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

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

  static getContractCacheDir(args: {
    chainId: string;
    contractAddress: 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: 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: string;
  }): string {
    return `${args.chainId}_${CacheRouter.COLLECTIBLES_KEY}_${args.safeAddress}`;
  }

  static getDelegatesCacheDir(args: {
    chainId: string;
    safeAddress?: string;
    delegate?: string;
    delegator?: 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 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: string;
    to?: string;
    module?: string;
    limit?: number;
    offset?: number;
  }): CacheDir {
    return new CacheDir(
      CacheRouter.getModuleTransactionsCacheKey(args),
      `${args.to}_${args.module}_${args.limit}_${args.offset}`,
    );
  }

  static getModuleTransactionsCacheKey(args: {
    chainId: string;
    safeAddress: 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: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.CREATION_TRANSACTION_KEY}_${args.safeAddress}`,
      '',
    );
  }

  static getAllTransactionsCacheDir(args: {
    chainId: string;
    safeAddress: 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: 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: 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: string;
  }): string {
    return `${args.chainId}_${CacheRouter.MESSAGES_KEY}_${args.safeAddress}`;
  }

  static getMessagesBySafeCacheDir(args: {
    chainId: string;
    safeAddress: 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: string }): string {
    return `${args.chainId}_${CacheRouter.RELAY_KEY}_${args.address}`;
  }

  static getRelayCacheDir(args: {
    chainId: string;
    address: 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;
    url?: string;
  }): CacheDir {
    return new CacheDir(
      `${args.chainId}_${CacheRouter.SAFE_APPS_KEY}`,
      `${args.clientUrl}_${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.FIAT_CODES_KEY, '');
  }
}

1	import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';	98✔
2
3	export class CacheRouter {	98✔
4	private static readonly ALL_TRANSACTIONS_KEY = 'all_transactions';	98✔
5	private static readonly BACKBONE_KEY = 'backbone';	98✔
6	private static readonly BALANCES_KEY = 'balances';	98✔
7	private static readonly CHAIN_KEY = 'chain';	98✔
8	private static readonly CHAINS_KEY = 'chains';	98✔
9	private static readonly COLLECTIBLES_KEY = 'collectibles';	98✔
10	private static readonly CONTRACT_KEY = 'contract';	98✔
11	private static readonly CREATION_TRANSACTION_KEY = 'creation_transaction';	98✔
12	private static readonly DELEGATES_KEY = 'delegates';	98✔
13	private static readonly FIAT_CODES_KEY = 'fiat_codes';	98✔
14	private static readonly INCOMING_TRANSFERS_KEY = 'incoming_transfers';	98✔
15	private static readonly MESSAGE_KEY = 'message';	98✔
16	private static readonly MESSAGES_KEY = 'messages';	98✔
17	private static readonly MODULE_TRANSACTION_KEY = 'module_transaction';	98✔
18	private static readonly MODULE_TRANSACTIONS_KEY = 'module_transactions';	98✔
19	private static readonly MULTISIG_TRANSACTION_KEY = 'multisig_transaction';	98✔
20	private static readonly MULTISIG_TRANSACTIONS_KEY = 'multisig_transactions';	98✔
21	private static readonly NATIVE_COIN_PRICE_KEY = 'native_coin_price';	98✔
22	private static readonly OWNERS_SAFE_KEY = 'owner_safes';	98✔
23	private static readonly RELAY_KEY = 'relay';	98✔
24	private static readonly SAFE_APPS_KEY = 'safe_apps';	98✔
25	private static readonly SAFE_KEY = 'safe';	98✔
26	private static readonly SINGLETONS_KEY = 'singletons';	98✔
27	private static readonly TOKEN_KEY = 'token';	98✔
28	private static readonly TOKEN_PRICE_KEY = 'token_price';	98✔
29	private static readonly TOKENS_KEY = 'tokens';	98✔
30	private static readonly TRANSFER_KEY = 'transfer';	98✔
31	private static readonly TRANSFERS_KEY = 'transfers';	98✔
32	private static readonly ZERION_BALANCES_KEY = 'zerion_balances';	98✔
33	private static readonly ZERION_COLLECTIBLES_KEY = 'zerion_collectibles';	98✔
34
35	static getBalancesCacheKey(args: {
36	chainId: string;
37	safeAddress: string;
38	}): string {
39	return `${args.chainId}_${CacheRouter.BALANCES_KEY}_${args.safeAddress}`;	58✔
40	}
41
42	static getBalancesCacheDir(args: {
43	chainId: string;
44	safeAddress: string;
45	trusted?: boolean;
46	excludeSpam?: boolean;
47	}): CacheDir {
48	return new CacheDir(	20✔
49	CacheRouter.getBalancesCacheKey(args),
50	`${args.trusted}_${args.excludeSpam}`,
51	);
52	}
53
54	// TODO: remove this prefixed key if eventually only one balances provider is used
55	static getZerionBalancesCacheKey(args: {
56	chainId: string;
57	safeAddress: string;
58	}): string {
59	return `${args.chainId}_${CacheRouter.ZERION_BALANCES_KEY}_${args.safeAddress}`;	8✔
60	}
61
62	static getZerionBalancesCacheDir(args: {
63	chainId: string;
64	safeAddress: string;
65	fiatCode: string;
66	}): CacheDir {
67	return new CacheDir(	8✔
68	CacheRouter.getZerionBalancesCacheKey(args),
69	args.fiatCode,
70	);
71	}
72
73	static getZerionCollectiblesCacheKey(args: {
74	chainId: string;
75	safeAddress: string;
76	}): string {
77	return `${args.chainId}_${CacheRouter.ZERION_COLLECTIBLES_KEY}_${args.safeAddress}`;	10✔
78	}
79
80	static getZerionCollectiblesCacheDir(args: {
81	chainId: string;
82	safeAddress: string;
83	limit?: number;
84	offset?: number;
85	}): CacheDir {
86	return new CacheDir(	10✔
87	CacheRouter.getZerionCollectiblesCacheKey(args),
88	`${args.limit}_${args.offset}`,
89	);
90	}
91
92	static getSafeCacheDir(args: {
93	chainId: string;
94	safeAddress: string;
95	}): CacheDir {
96	return new CacheDir(CacheRouter.getSafeCacheKey(args), '');	198✔
97	}
98
99	static getSafeCacheKey(args: {
100	chainId: string;
101	safeAddress: string;
102	}): string {
103	return `${args.chainId}_${CacheRouter.SAFE_KEY}_${args.safeAddress}`;	220✔
104	}
105
106	static getContractCacheDir(args: {
107	chainId: string;
108	contractAddress: string;
109	}): CacheDir {
110	return new CacheDir(	580✔
111	`${args.chainId}_${CacheRouter.CONTRACT_KEY}_${args.contractAddress}`,
112	'',
113	);
114	}
115
116	static getBackboneCacheDir(chainId: string): CacheDir {
117	return new CacheDir(`${chainId}_${CacheRouter.BACKBONE_KEY}`, '');	12✔
118	}
119
120	static getSingletonsCacheDir(chainId: string): CacheDir {
121	return new CacheDir(`${chainId}_${CacheRouter.SINGLETONS_KEY}`, '');	62✔
122	}
123
124	static getCollectiblesCacheDir(args: {
125	chainId: string;
126	safeAddress: string;
127	limit?: number;
128	offset?: number;
129	trusted?: boolean;
130	excludeSpam?: boolean;
131	}): CacheDir {
132	return new CacheDir(	10✔
133	CacheRouter.getCollectiblesKey(args),
134	`${args.limit}_${args.offset}_${args.trusted}_${args.excludeSpam}`,
135	);
136	}
137
138	static getCollectiblesKey(args: {
139	chainId: string;
140	safeAddress: string;
141	}): string {
142	return `${args.chainId}_${CacheRouter.COLLECTIBLES_KEY}_${args.safeAddress}`;	46✔
143	}
144
145	static getDelegatesCacheDir(args: {
146	chainId: string;
147	safeAddress?: string;
148	delegate?: string;
149	delegator?: string;
150	label?: string;
151	limit?: number;
152	offset?: number;
153	}): CacheDir {
154	return new CacheDir(	6✔
155	`${args.chainId}_${CacheRouter.DELEGATES_KEY}_${args.safeAddress}`,
156	`${args.delegate}_${args.delegator}_${args.label}_${args.limit}_${args.offset}`,
157	);
158	}
159
160	static getTransferCacheDir(args: {
161	chainId: string;
162	transferId: string;
163	}): CacheDir {
164	return new CacheDir(	4✔
165	`${args.chainId}_${CacheRouter.TRANSFER_KEY}_${args.transferId}`,
166	'',
167	);
168	}
169
170	static getTransfersCacheDir(args: {
171	chainId: string;
172	safeAddress: string;
173	onlyErc20: boolean;
174	onlyErc721: boolean;
175	limit?: number;
176	offset?: number;
177	}): CacheDir {
178	return new CacheDir(	112✔
179	CacheRouter.getTransfersCacheKey(args),
180	`${args.onlyErc20}_${args.onlyErc721}_${args.limit}_${args.offset}`,
181	);
182	}
183
184	static getTransfersCacheKey(args: {
185	chainId: string;
186	safeAddress: string;
187	}): string {
188	return `${args.chainId}_${CacheRouter.TRANSFERS_KEY}_${args.safeAddress}`;	162✔
189	}
190
191	static getModuleTransactionCacheDir(args: {
192	chainId: string;
193	moduleTransactionId: string;
194	}): CacheDir {
195	return new CacheDir(	6✔
196	`${args.chainId}_${CacheRouter.MODULE_TRANSACTION_KEY}_${args.moduleTransactionId}`,
197	'',
198	);
199	}
200
201	static getModuleTransactionsCacheDir(args: {
202	chainId: string;
203	safeAddress: string;
204	to?: string;
205	module?: string;
206	limit?: number;
207	offset?: number;
208	}): CacheDir {
209	return new CacheDir(	64✔
210	CacheRouter.getModuleTransactionsCacheKey(args),
211	`${args.to}_${args.module}_${args.limit}_${args.offset}`,
212	);
213	}
214
215	static getModuleTransactionsCacheKey(args: {
216	chainId: string;
217	safeAddress: string;
218	}): string {
219	return `${args.chainId}_${CacheRouter.MODULE_TRANSACTIONS_KEY}_${args.safeAddress}`;	72✔
220	}
221
222	static getIncomingTransfersCacheDir(args: {
223	chainId: string;
224	safeAddress: string;
225	executionDateGte?: string;
226	executionDateLte?: string;
227	to?: string;
228	value?: string;
229	tokenAddress?: string;
230	limit?: number;
231	offset?: number;
232	}): CacheDir {
233	return new CacheDir(	12✔
234	CacheRouter.getIncomingTransfersCacheKey(args),
235	`${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.tokenAddress}_${args.limit}_${args.offset}`,
236	);
237	}
238
239	static getIncomingTransfersCacheKey(args: {
240	chainId: string;
241	safeAddress: string;
242	}): string {
243	return `${args.chainId}_${CacheRouter.INCOMING_TRANSFERS_KEY}_${args.safeAddress}`;	32✔
244	}
245
246	static getMultisigTransactionsCacheDir(args: {
247	chainId: string;
248	safeAddress: string;
249	ordering?: string;
250	executed?: boolean;
251	trusted?: boolean;
252	executionDateGte?: string;
253	executionDateLte?: string;
254	to?: string;
255	value?: string;
256	nonce?: string;
257	nonceGte?: number;
258	limit?: number;
259	offset?: number;
260	}): CacheDir {
261	return new CacheDir(	156✔
262	CacheRouter.getMultisigTransactionsCacheKey(args),
263	`${args.ordering}_${args.executed}_${args.trusted}_${args.executionDateGte}_${args.executionDateLte}_${args.to}_${args.value}_${args.nonce}_${args.nonceGte}_${args.limit}_${args.offset}`,
264	);
265	}
266
267	static getMultisigTransactionsCacheKey(args: {
268	chainId: string;
269	safeAddress: string;
270	}): string {
271	return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTIONS_KEY}_${args.safeAddress}`;	228✔
272	}
273
274	static getMultisigTransactionCacheDir(args: {
275	chainId: string;
276	safeTransactionHash: string;
277	}): CacheDir {
278	return new CacheDir(CacheRouter.getMultisigTransactionCacheKey(args), '');	18✔
279	}
280
281	static getMultisigTransactionCacheKey(args: {
282	chainId: string;
283	safeTransactionHash: string;
284	}): string {
285	return `${args.chainId}_${CacheRouter.MULTISIG_TRANSACTION_KEY}_${args.safeTransactionHash}`;	54✔
286	}
287
288	static getCreationTransactionCacheDir(args: {
289	chainId: string;
290	safeAddress: string;
291	}): CacheDir {
292	return new CacheDir(	4✔
293	`${args.chainId}_${CacheRouter.CREATION_TRANSACTION_KEY}_${args.safeAddress}`,
294	'',
295	);
296	}
297
298	static getAllTransactionsCacheDir(args: {
299	chainId: string;
300	safeAddress: string;
301	ordering?: string;
302	executed?: boolean;
303	queued?: boolean;
304	limit?: number;
305	offset?: number;
306	}): CacheDir {
307	return new CacheDir(	32✔
308	CacheRouter.getAllTransactionsKey(args),
309	`${args.ordering}_${args.executed}_${args.queued}_${args.limit}_${args.offset}`,
310	);
311	}
312
313	static getAllTransactionsKey(args: {
314	chainId: string;
315	safeAddress: string;
316	}): string {
317	return `${args.chainId}_${CacheRouter.ALL_TRANSACTIONS_KEY}_${args.safeAddress}`;	90✔
318	}
319
320	static getTokenCacheDir(args: {
321	chainId: string;
322	address: string;
323	}): CacheDir {
324	return new CacheDir(	262✔
325	`${args.chainId}_${CacheRouter.TOKEN_KEY}_${args.address}`,
326	'',
327	);
328	}
329
330	static getTokensCacheKey(chainId: string): string {
UNCOV 331	return `${chainId}_${CacheRouter.TOKENS_KEY}`;	×
332	}
333
334	static getTokensCacheDir(args: {
335	chainId: string;
336	limit?: number;
337	offset?: number;
338	}): CacheDir {
UNCOV 339	return new CacheDir(	×
340	CacheRouter.getTokensCacheKey(args.chainId),
341	`${args.limit}_${args.offset}`,
342	);
343	}
344
345	static getSafesByOwnerCacheDir(args: {
346	chainId: string;
347	ownerAddress: string;
348	}): CacheDir {
349	return new CacheDir(	14✔
350	`${args.chainId}_${CacheRouter.OWNERS_SAFE_KEY}_${args.ownerAddress}`,
351	'',
352	);
353	}
354
355	static getMessageByHashCacheKey(args: {
356	chainId: string;
357	messageHash: string;
358	}): string {
359	return `${args.chainId}_${CacheRouter.MESSAGE_KEY}_${args.messageHash}`;	16✔
360	}
361
362	static getMessageByHashCacheDir(args: {
363	chainId: string;
364	messageHash: string;
365	}): CacheDir {
366	return new CacheDir(this.getMessageByHashCacheKey(args), '');	12✔
367	}
368
369	static getMessagesBySafeCacheKey(args: {
370	chainId: string;
371	safeAddress: string;
372	}): string {
373	return `${args.chainId}_${CacheRouter.MESSAGES_KEY}_${args.safeAddress}`;	72✔
374	}
375
376	static getMessagesBySafeCacheDir(args: {
377	chainId: string;
378	safeAddress: string;
379	limit?: number;
380	offset?: number;
381	}): CacheDir {
382	return new CacheDir(	64✔
383	this.getMessagesBySafeCacheKey(args),
384	`${args.limit}_${args.offset}`,
385	);
386	}
387
388	static getChainsCacheKey(): string {
389	return CacheRouter.CHAINS_KEY;	22✔
390	}
391
392	static getChainsCacheDir(args: {
393	limit?: number;
394	offset?: number;
395	}): CacheDir {
396	return new CacheDir(	16✔
397	CacheRouter.getChainsCacheKey(),
398	`${args.limit}_${args.offset}`,
399	);
400	}
401
402	static getChainCacheKey(chainId: string): string {
403	return `${chainId}_${CacheRouter.CHAIN_KEY}`;	946✔
404	}
405
406	static getChainCacheDir(chainId: string): CacheDir {
407	return new CacheDir(CacheRouter.getChainCacheKey(chainId), '');	940✔
408	}
409
410	static getRelayKey(args: { chainId: string; address: string }): string {
411	return `${args.chainId}_${CacheRouter.RELAY_KEY}_${args.address}`;	20✔
412	}
413
414	static getRelayCacheDir(args: {
415	chainId: string;
416	address: string;
417	}): CacheDir {
418	return new CacheDir(CacheRouter.getRelayKey(args), '');	20✔
419	}
420
421	static getSafeAppsKey(chainId: string): string {
422	return `${chainId}_${CacheRouter.SAFE_APPS_KEY}`;	6✔
423	}
424
425	static getSafeAppsCacheDir(args: {
426	chainId?: string;
427	clientUrl?: string;
428	url?: string;
429	}): CacheDir {
430	return new CacheDir(	68✔
431	`${args.chainId}_${CacheRouter.SAFE_APPS_KEY}`,
432	`${args.clientUrl}_${args.url}`,
433	);
434	}
435
436	static getNativeCoinPriceCacheDir(args: {
437	nativeCoinId: string;
438	fiatCode: string;
439	}): CacheDir {
440	return new CacheDir(	8✔
441	`${args.nativeCoinId}_${CacheRouter.NATIVE_COIN_PRICE_KEY}_${args.fiatCode}`,
442	'',
443	);
444	}
445
446	static getTokenPriceCacheDir(args: {
447	chainName: string;
448	fiatCode: string;
449	tokenAddress: string;
450	}): CacheDir {
451	return new CacheDir(	60✔
452	`${args.chainName}_${CacheRouter.TOKEN_PRICE_KEY}_${args.tokenAddress}_${args.fiatCode}`,
453	'',
454	);
455	}
456
457	static getPriceFiatCodesCacheDir(): CacheDir {
458	return new CacheDir(CacheRouter.FIAT_CODES_KEY, '');	12✔
459	}
460	}

safe-global / safe-client-gateway / 7932159520

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