9515987424

Committed 14 Jun 2024 12:19PM UTC coverage: 12.851% (+0.002%) from 12.849%

Build # 9515987424

Build Type

Pull #8131

github

Committed by

web-flow

Commit Message

Merge 6b112e244 into d2f57ef0e

Pull Request Pull Request #8131: Create contest UI fixes

Run Details

3847 of 35133 branches covered (10.95%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 5 files covered. (0.0%)

2 existing lines in 1 file now uncovered.

5190 of 35187 relevant lines covered (14.75%)

4.75 hits per line

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

1.38

/libs/model/src/services/tokenBalanceCache/util.ts

import { HttpBatchClient, Tendermint34Client } from '@cosmjs/tendermint-rpc';
import { logger } from '@hicommonwealth/core';
import { ZERO_ADDRESS } from '@hicommonwealth/shared';
import { ethers } from 'ethers';
import { fileURLToPath } from 'url';
import * as AbiCoder from 'web3-eth-abi';
import { ChainNodeAttributes } from '../../models/chain_node';
import { Balances, GetTendermintClientOptions } from './types';

const __filename = fileURLToPath(import.meta.url);
const log = logger(__filename);

/**
 * This function batches hundreds of RPC requests (1 per address) into a few batched RPC requests.
 * This function cannot be used for on-chain batching since several hundred addresses are batched
 * for a single RPC request (not 1 RPC request per address).
 */
export async function evmOffChainRpcBatching(
  source: {
    evmChainId: number;
    url: string;
    contractAddress?: string;
  },
  rpc: {
    method: 'eth_call' | 'eth_getBalance';
    getParams: (
      abiCoder: typeof AbiCoder,
      address: string,
      contractAddress?: string,
    ) => string | Record<string, string>;
    batchSize?: number;
  },
  addresses: string[],
): Promise<{ balances: Balances; failedAddresses: string[] }> {
  if (!rpc.batchSize) rpc.batchSize = 500;

  const batchRequestPromises = [];
  // maps an RPC request id to an address
  const idAddressMap: Balances = {};

  // iterate through addresses in batches of size rpcBatchSize creating a single request for each batch
  let id = 1;
  for (
    let startIndex = 0;
    startIndex < addresses.length;
    startIndex += rpc.batchSize
  ) {
    const endIndex = Math.min(startIndex + rpc.batchSize, addresses.length);
    const batchAddresses = addresses.slice(startIndex, endIndex);
    const rpcRequests = [];
    for (const address of batchAddresses) {
      rpcRequests.push({
        method: rpc.method,
        params: [
          rpc.getParams(AbiCoder, address, source.contractAddress),
          'latest',
        ],
        id,
        jsonrpc: '2.0',
      });
      idAddressMap[id] = address;
      ++id;
    }

    batchRequestPromises.push(
      fetch(source.url, {
        method: 'POST',
        body: JSON.stringify(rpcRequests),
        headers: { 'Content-Type': 'application/json' },
      }),
    );
  }

  let failedAddresses: string[] = [];
  const jsonPromises: Promise<any>[] = [];
  const responses = await Promise.allSettled(batchRequestPromises);
  const chainNodeErrorMsg =
    `${failingChainNodeError} RPC batch request failed for method '${rpc.method}' ` +
    `with batch size ${rpc.batchSize} on evm chain id ${source.evmChainId}${
      source.contractAddress ? ` for token ${source.contractAddress}` : ''
    }.`;
  responses.forEach((res, index) => {
    // handle a failed batch request
    if (res.status === 'rejected') {
      const startIndex = rpc.batchSize! * index;
      const relevantAddresses = addresses.slice(
        startIndex,
        Math.min(startIndex + rpc.batchSize!, addresses.length),
      );
      failedAddresses = [...failedAddresses, ...relevantAddresses];
      log.fatal(chainNodeErrorMsg, res.reason);
    } else {
      jsonPromises.push(res.value.json());
    }
  });

  let datas;
  try {
    datas = (await Promise.all(jsonPromises)).flat();
  } catch (e) {
    log.fatal(chainNodeErrorMsg, e instanceof Error ? e : undefined);
    return {
      balances: {},
      failedAddresses: addresses,
    };
  }

  const balances: Balances = {};
  for (const data of datas) {
    if (data.error) {
      failedAddresses.push(idAddressMap[data.id]);
      const msg = `RPC request failed on EVM chain id ${source.evmChainId}${
        source.contractAddress ? `for token ${source.contractAddress}` : ''
      }.`;
      log.error(msg, data.error);
      continue;
    }

    const address = idAddressMap[data.id];
    balances[address] = source.contractAddress
      ? String(AbiCoder.decodeParameter('uint256', data.result))
      : ethers.BigNumber.from(data.result).toString();
  }

  return { balances, failedAddresses };
}

/**
 * This function uses the on-chain Balance Fetcher contract to batch fetch balances
 * for many different addresses using a single RPC request. This is extremely scalable
 * because we can batch multiple requests together e.g. each on-chain call can batch 1k
 * paired with 100 batched RPC requests that means we can fetch 100k address balances
 * from a single HTTP request. ONLY WORKS FOR ERC20 and ETH!
 */
export async function evmBalanceFetcherBatching(
  source: {
    evmChainId: number;
    url: string;
    contractAddress?: string;
  },
  rpc: {
    batchSize?: number;
  },
  addresses: string[],
): Promise<{ balances: Balances; failedAddresses: string[] }> {
  if (!rpc.batchSize) rpc.batchSize = 500;
  // 0x0 tells the on-chain contract to only return ETH balances
  if (!source.contractAddress) source.contractAddress = ZERO_ADDRESS;

  const rpcRequests = [];

  for (
    let startIndex = 0;
    startIndex < addresses.length;
    startIndex += rpc.batchSize
  ) {
    const endIndex = Math.min(startIndex + rpc.batchSize, addresses.length);
    const batchAddresses = addresses.slice(startIndex, endIndex);

    const calldata =
      '0xf0002ea9' +
      AbiCoder.encodeParameters(
        ['address[]', 'address[]'],
        [batchAddresses, [source.contractAddress]],
      ).substring(2);

    rpcRequests.push({
      method: 'eth_call',
      params: [
        {
          to: mapNodeToBalanceFetcherContract(source.evmChainId),
          data: calldata,
        },
        'latest',
      ],
      id: startIndex,
      jsonrpc: '2.0',
    });
  }

  const errorMsg =
    `On-chain batch request failed ` +
    `with batch size ${rpc.batchSize} on evm chain id ${source.evmChainId}${
      source.contractAddress ? `for token ${source.contractAddress}` : ''
    }.`;

  const datas = await evmRpcRequest(source.url, rpcRequests, errorMsg);
  if (!datas)
    return {
      balances: {},
      failedAddresses: addresses,
    };

  const addressBalanceMap: Balances = {};
  let failedAddresses: string[] = [];

  if (datas.error) {
    log.error(errorMsg, datas.error);
    return { balances: {}, failedAddresses: addresses };
  } else {
    for (const data of datas) {
      // this replicates the batches used when creating the requests
      // note -> data.id is the startIndex defined in the loop above
      const endIndex = Math.min(data.id + rpc.batchSize, addresses.length);
      const relevantAddresses = addresses.slice(data.id, endIndex);

      if (data.error) {
        failedAddresses = [...failedAddresses, ...relevantAddresses];
        const msg =
          'Balance Fetcher Contract request failed on EVM ' +
          `chain id: ${source.evmChainId}${
            source.contractAddress ? `for token ${source.contractAddress}` : ''
          }.`;
        log.error(msg, data.error);
        continue;
      }

      const balances = AbiCoder.decodeParameter(
        'uint256[]',
        data.result,
      ) as number[];
      relevantAddresses.forEach(
        (key, i) => (addressBalanceMap[key] = String(balances[i])),
      );
    }
  }

  return { balances: addressBalanceMap, failedAddresses };
}

/**
 * Maps an EVM chain id to the contract address of that chains Balance Checker contract.
 * All supported contract addresses can be found here: https://github.com/wbobeirne/eth-balance-checker
 * Some contract addresses are available in the open PRs or issues.
 */
export function mapNodeToBalanceFetcherContract(
  ethChainId: ChainNodeAttributes['eth_chain_id'],
) {
  switch (ethChainId) {
    case 1: // Ethereum Mainnet
    case 1337: // Local Ganache - assuming fork of mainnet
      return '0xb1f8e55c7f64d203c1400b9d8555d050f94adf39';
    case 5: // Goerli
      return '0x9788C4E93f9002a7ad8e72633b11E8d1ecd51f9b';
    case 56: // BSC
    case 97: // BSC Testnet
      return '0x2352c63A83f9Fd126af8676146721Fa00924d7e4';
    case 137: // Polygon
    case 80001: // Polygon Mumbai
      return '0x2352c63A83f9Fd126af8676146721Fa00924d7e4';
    case 10: // Optimism Mainnet
      return '0xB1c568e9C3E6bdaf755A60c7418C269eb11524FC';
    case 42161: // Arbitrum One
      return '0x151E24A486D7258dd7C33Fb67E4bB01919B7B32c';
    case 43114: // Avalanche
      return '0xD023D153a0DFa485130ECFdE2FAA7e612EF94818';
    case 43113: // Avalanche Testnet
      return '0x100665685d533F65bdD0BD1d65ca6387FC4F4FDB';
    case 250: // Fantom
      return '0x07f697424ABe762bB808c109860c04eA488ff92B';
    case 4002: // Fantom Testnet
      return '0x8B14C79f24986B127EC7208cE4e93E8e45125F8f';
    case 1284: // Moonbeam -- unverified
      return '0xf614056a46e293DD701B9eCeBa5df56B354b75f9';
    case 1285: // Moonriver -- unverified
      return '0xDEAa846cca7FEc9e76C8e4D56A55A75bb0973888';
    case 1313161554: // Aurora Mainnet -- unverified
      return '0x100665685d533F65bdD0BD1d65ca6387FC4F4FDB';
    case 1313161555: // Aurora Testnet -- unverified
      return '0x60d2714e1a9Fd5e9580A66f6aF6b259C77A87b09';
    case 25: // Cronos Mainnet -- unverified
      return '0x8b14c79f24986b127ec7208ce4e93e8e45125f8f';
    case 338: // Cronos Testnet -- unverified
      return '0x8b14c79f24986b127ec7208ce4e93e8e45125f8f';
    case 66: // OKXChain Mainnet:
      return '0x42CD9068d471c861796D56A37f8BFEae19DAC12F';
    case 9001: // Evmos -- unverified
      return '0x42CD9068d471c861796D56A37f8BFEae19DAC12F';
    case 59144: // Linea Mainnet -- unverified
      return '0xF62e6a41561b3650a69Bb03199C735e3E3328c0D';
    case 59140: // Linea Testnet -- unverified
      return '0x10dAd7Ca3921471f616db788D9300DC97Db01783';
    case 11155111: // Sepolia
      return '0xBfbCed302deD369855fc5f7668356e123ca4B329';
  }
}

export const failingChainNodeError = 'FAILING OR RATE LIMITED CHAIN NODE:';

export async function evmRpcRequest(
  rpcEndpoint: string,
  rawRequestBody: Record<string, unknown> | Array<Record<string, unknown>>,
  errorMsg: string,
) {
  let data;
  try {
    const response = await fetch(rpcEndpoint, {
      method: 'POST',
      body: JSON.stringify(rawRequestBody),
      headers: { 'Content-Type': 'application/json' },
    });
    data = await response.json();
  } catch (e) {
    const augmentedMsg = `${failingChainNodeError} ${errorMsg}`;
    log.fatal(augmentedMsg, e instanceof Error ? e : undefined);
  }

  return data;
}

export async function getTendermintClient(
  options: GetTendermintClientOptions,
): Promise<Tendermint34Client> {
  const batchClient = new HttpBatchClient(
    options.chainNode?.private_url || options.chainNode.url,
    {
      batchSizeLimit: options.batchSize || 100,
      dispatchInterval: 10,
    },
  );
  return await Tendermint34Client.create(batchClient);
}

1	import { HttpBatchClient, Tendermint34Client } from '@cosmjs/tendermint-rpc';
2	import { logger } from '@hicommonwealth/core';
3	import { ZERO_ADDRESS } from '@hicommonwealth/shared';
4	import { ethers } from 'ethers';
5	import { fileURLToPath } from 'url';
6	import * as AbiCoder from 'web3-eth-abi';
7	import { ChainNodeAttributes } from '../../models/chain_node';
8	import { Balances, GetTendermintClientOptions } from './types';
9
10	const __filename = fileURLToPath(import.meta.url);	12✔
11	const log = logger(__filename);	12✔
12
13	/**
14	* This function batches hundreds of RPC requests (1 per address) into a few batched RPC requests.
15	* This function cannot be used for on-chain batching since several hundred addresses are batched
16	* for a single RPC request (not 1 RPC request per address).
17	*/
18	export async function evmOffChainRpcBatching(
19	source: {
20	evmChainId: number;
21	url: string;
22	contractAddress?: string;
23	},
24	rpc: {
25	method: 'eth_call' \| 'eth_getBalance';
26	getParams: (
27	abiCoder: typeof AbiCoder,
28	address: string,
29	contractAddress?: string,
30	) => string \| Record<string, string>;
31	batchSize?: number;
32	},
33	addresses: string[],
34	): Promise<{ balances: Balances; failedAddresses: string[] }> {
35	if (!rpc.batchSize) rpc.batchSize = 500;	×
36
37	const batchRequestPromises = [];	×
38	// maps an RPC request id to an address
39	const idAddressMap: Balances = {};	×
40
41	// iterate through addresses in batches of size rpcBatchSize creating a single request for each batch
42	let id = 1;	×
43	for (	×
44	let startIndex = 0;	×
45	startIndex < addresses.length;
46	startIndex += rpc.batchSize
47	) {
48	const endIndex = Math.min(startIndex + rpc.batchSize, addresses.length);	×
49	const batchAddresses = addresses.slice(startIndex, endIndex);	×
50	const rpcRequests = [];	×
51	for (const address of batchAddresses) {	×
52	rpcRequests.push({	×
53	method: rpc.method,
54	params: [
55	rpc.getParams(AbiCoder, address, source.contractAddress),
56	'latest',
57	],
58	id,
59	jsonrpc: '2.0',
60	});
61	idAddressMap[id] = address;	×
62	++id;	×
63	}
64
65	batchRequestPromises.push(	×
66	fetch(source.url, {
67	method: 'POST',
68	body: JSON.stringify(rpcRequests),
69	headers: { 'Content-Type': 'application/json' },
70	}),
71	);
72	}
73
74	let failedAddresses: string[] = [];	×
75	const jsonPromises: Promise<any>[] = [];	×
76	const responses = await Promise.allSettled(batchRequestPromises);	×
77	const chainNodeErrorMsg =
78	`${failingChainNodeError} RPC batch request failed for method '${rpc.method}' ` +	×
79	`with batch size ${rpc.batchSize} on evm chain id ${source.evmChainId}${
80	source.contractAddress ? ` for token ${source.contractAddress}` : ''	×
81	}.`;
82	responses.forEach((res, index) => {	×
83	// handle a failed batch request
84	if (res.status === 'rejected') {	×
85	const startIndex = rpc.batchSize! * index;	×
86	const relevantAddresses = addresses.slice(	×
87	startIndex,
88	Math.min(startIndex + rpc.batchSize!, addresses.length),
89	);
90	failedAddresses = [...failedAddresses, ...relevantAddresses];	×
91	log.fatal(chainNodeErrorMsg, res.reason);	×
92	} else {
93	jsonPromises.push(res.value.json());	×
94	}
95	});
96
97	let datas;
98	try {	×
99	datas = (await Promise.all(jsonPromises)).flat();	×
100	} catch (e) {
101	log.fatal(chainNodeErrorMsg, e instanceof Error ? e : undefined);	×
102	return {	×
103	balances: {},
104	failedAddresses: addresses,
105	};
106	}
107
108	const balances: Balances = {};	×
109	for (const data of datas) {	×
110	if (data.error) {	×
111	failedAddresses.push(idAddressMap[data.id]);	×
112	const msg = `RPC request failed on EVM chain id ${source.evmChainId}${	×
113	source.contractAddress ? `for token ${source.contractAddress}` : ''	×
114	}.`;
115	log.error(msg, data.error);	×
116	continue;	×
117	}
118
119	const address = idAddressMap[data.id];	×
120	balances[address] = source.contractAddress	×
121	? String(AbiCoder.decodeParameter('uint256', data.result))
122	: ethers.BigNumber.from(data.result).toString();
123	}
124
125	return { balances, failedAddresses };	×
126	}
127
128	/**
129	* This function uses the on-chain Balance Fetcher contract to batch fetch balances
130	* for many different addresses using a single RPC request. This is extremely scalable
131	* because we can batch multiple requests together e.g. each on-chain call can batch 1k
132	* paired with 100 batched RPC requests that means we can fetch 100k address balances
133	* from a single HTTP request. ONLY WORKS FOR ERC20 and ETH!
134	*/
135	export async function evmBalanceFetcherBatching(
136	source: {
137	evmChainId: number;
138	url: string;
139	contractAddress?: string;
140	},
141	rpc: {
142	batchSize?: number;
143	},
144	addresses: string[],
145	): Promise<{ balances: Balances; failedAddresses: string[] }> {
146	if (!rpc.batchSize) rpc.batchSize = 500;	×
147	// 0x0 tells the on-chain contract to only return ETH balances
NEW 148	if (!source.contractAddress) source.contractAddress = ZERO_ADDRESS;	×
149
150	const rpcRequests = [];	×
151
152	for (	×
153	let startIndex = 0;	×
154	startIndex < addresses.length;
155	startIndex += rpc.batchSize
156	) {
157	const endIndex = Math.min(startIndex + rpc.batchSize, addresses.length);	×
158	const batchAddresses = addresses.slice(startIndex, endIndex);	×
159
160	const calldata =
161	'0xf0002ea9' +	×
162	AbiCoder.encodeParameters(
163	['address[]', 'address[]'],
164	[batchAddresses, [source.contractAddress]],
165	).substring(2);
166
167	rpcRequests.push({	×
168	method: 'eth_call',
169	params: [
170	{
171	to: mapNodeToBalanceFetcherContract(source.evmChainId),
172	data: calldata,
173	},
174	'latest',
175	],
176	id: startIndex,
177	jsonrpc: '2.0',
178	});
179	}
180
181	const errorMsg =
182	`On-chain batch request failed ` +	×
183	`with batch size ${rpc.batchSize} on evm chain id ${source.evmChainId}${
184	source.contractAddress ? `for token ${source.contractAddress}` : ''	×
185	}.`;
186
187	const datas = await evmRpcRequest(source.url, rpcRequests, errorMsg);	×
188	if (!datas)	×
189	return {	×
190	balances: {},
191	failedAddresses: addresses,
192	};
193
194	const addressBalanceMap: Balances = {};	×
195	let failedAddresses: string[] = [];	×
196
197	if (datas.error) {	×
198	log.error(errorMsg, datas.error);	×
199	return { balances: {}, failedAddresses: addresses };	×
200	} else {
201	for (const data of datas) {	×
202	// this replicates the batches used when creating the requests
203	// note -> data.id is the startIndex defined in the loop above
204	const endIndex = Math.min(data.id + rpc.batchSize, addresses.length);	×
205	const relevantAddresses = addresses.slice(data.id, endIndex);	×
206
207	if (data.error) {	×
208	failedAddresses = [...failedAddresses, ...relevantAddresses];	×
209	const msg =
210	'Balance Fetcher Contract request failed on EVM ' +	×
211	`chain id: ${source.evmChainId}${
212	source.contractAddress ? `for token ${source.contractAddress}` : ''	×
213	}.`;
214	log.error(msg, data.error);	×
215	continue;	×
216	}
217
218	const balances = AbiCoder.decodeParameter(	×
219	'uint256[]',
220	data.result,
221	) as number[];
222	relevantAddresses.forEach(	×
223	(key, i) => (addressBalanceMap[key] = String(balances[i])),	×
224	);
225	}
226	}
227
228	return { balances: addressBalanceMap, failedAddresses };	×
229	}
230
231	/**
232	* Maps an EVM chain id to the contract address of that chains Balance Checker contract.
233	* All supported contract addresses can be found here: https://github.com/wbobeirne/eth-balance-checker
234	* Some contract addresses are available in the open PRs or issues.
235	*/
236	export function mapNodeToBalanceFetcherContract(
237	ethChainId: ChainNodeAttributes['eth_chain_id'],
238	) {
239	switch (ethChainId) {	×
240	case 1: // Ethereum Mainnet
241	case 1337: // Local Ganache - assuming fork of mainnet
242	return '0xb1f8e55c7f64d203c1400b9d8555d050f94adf39';	×
243	case 5: // Goerli
244	return '0x9788C4E93f9002a7ad8e72633b11E8d1ecd51f9b';	×
245	case 56: // BSC
246	case 97: // BSC Testnet
247	return '0x2352c63A83f9Fd126af8676146721Fa00924d7e4';	×
248	case 137: // Polygon
249	case 80001: // Polygon Mumbai
250	return '0x2352c63A83f9Fd126af8676146721Fa00924d7e4';	×
251	case 10: // Optimism Mainnet
252	return '0xB1c568e9C3E6bdaf755A60c7418C269eb11524FC';	×
253	case 42161: // Arbitrum One
254	return '0x151E24A486D7258dd7C33Fb67E4bB01919B7B32c';	×
255	case 43114: // Avalanche
256	return '0xD023D153a0DFa485130ECFdE2FAA7e612EF94818';	×
257	case 43113: // Avalanche Testnet
258	return '0x100665685d533F65bdD0BD1d65ca6387FC4F4FDB';	×
259	case 250: // Fantom
260	return '0x07f697424ABe762bB808c109860c04eA488ff92B';	×
261	case 4002: // Fantom Testnet
262	return '0x8B14C79f24986B127EC7208cE4e93E8e45125F8f';	×
263	case 1284: // Moonbeam -- unverified
264	return '0xf614056a46e293DD701B9eCeBa5df56B354b75f9';	×
265	case 1285: // Moonriver -- unverified
266	return '0xDEAa846cca7FEc9e76C8e4D56A55A75bb0973888';	×
267	case 1313161554: // Aurora Mainnet -- unverified
268	return '0x100665685d533F65bdD0BD1d65ca6387FC4F4FDB';	×
269	case 1313161555: // Aurora Testnet -- unverified
270	return '0x60d2714e1a9Fd5e9580A66f6aF6b259C77A87b09';	×
271	case 25: // Cronos Mainnet -- unverified
272	return '0x8b14c79f24986b127ec7208ce4e93e8e45125f8f';	×
273	case 338: // Cronos Testnet -- unverified
274	return '0x8b14c79f24986b127ec7208ce4e93e8e45125f8f';	×
275	case 66: // OKXChain Mainnet:
276	return '0x42CD9068d471c861796D56A37f8BFEae19DAC12F';	×
277	case 9001: // Evmos -- unverified
278	return '0x42CD9068d471c861796D56A37f8BFEae19DAC12F';	×
279	case 59144: // Linea Mainnet -- unverified
280	return '0xF62e6a41561b3650a69Bb03199C735e3E3328c0D';	×
281	case 59140: // Linea Testnet -- unverified
282	return '0x10dAd7Ca3921471f616db788D9300DC97Db01783';	×
283	case 11155111: // Sepolia
284	return '0xBfbCed302deD369855fc5f7668356e123ca4B329';	×
285	}
286	}
287
288	export const failingChainNodeError = 'FAILING OR RATE LIMITED CHAIN NODE:';	12✔
289
290	export async function evmRpcRequest(
291	rpcEndpoint: string,
292	rawRequestBody: Record<string, unknown> \| Array<Record<string, unknown>>,
293	errorMsg: string,
294	) {
295	let data;
296	try {	×
297	const response = await fetch(rpcEndpoint, {	×
298	method: 'POST',
299	body: JSON.stringify(rawRequestBody),
300	headers: { 'Content-Type': 'application/json' },
301	});
302	data = await response.json();	×
303	} catch (e) {
304	const augmentedMsg = `${failingChainNodeError} ${errorMsg}`;	×
305	log.fatal(augmentedMsg, e instanceof Error ? e : undefined);	×
306	}
307
308	return data;	×
309	}
310
311	export async function getTendermintClient(
312	options: GetTendermintClientOptions,
313	): Promise<Tendermint34Client> {
314	const batchClient = new HttpBatchClient(	×
315	options.chainNode?.private_url \|\| options.chainNode.url,	×
316	{
317	batchSizeLimit: options.batchSize \|\| 100,	×
318	dispatchInterval: 10,
319	},
320	);
321	return await Tendermint34Client.create(batchClient);	×
322	}

hicommonwealth / commonwealth / 9515987424

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