9960585581

Committed 16 Jul 2024 04:25PM UTC coverage: 48.233% (-0.1%) from 48.34%

Build # 9960585581

Build Type

push

github

Committed by

web-flow

Commit Message

Add Accounts Datasource cache layer (#1760)

Adds cache management to AccountDatasource, along with its associated tests.

Run Details

415 of 2591 branches covered (16.02%)

Branch coverage included in aggregate %.

8 of 51 new or added lines in 2 files covered. (15.69%)

3 existing lines in 1 file now uncovered.

4281 of 7145 relevant lines covered (59.92%)

13.02 hits per line

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

59.57

/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 CREATION_TRANSACTION_KEY = 'creation_transaction';
  private static readonly DELEGATES_KEY = 'delegates';
  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 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}`,
      '',
    );
  }
}

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

safe-global / safe-client-gateway / 9960585581

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