chore: npm run lint:fix

Signed-off-by: Miroslav Bajtoš <oss@bajtos.net>

Author: bajtos

.github/workflows/ci.yml

@@ -8,7 +8,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - run: curl -L https://github.com/filecoin-station/zinnia/releases/download/${{ env.ZINNIA_VERSION }}/zinnia-linux-x64.tar.gz | tar -xz
+      - run:
+          curl -L https://github.com/filecoin-station/zinnia/releases/download/${{
+          env.ZINNIA_VERSION }}/zinnia-linux-x64.tar.gz | tar -xz
       - run: ./zinnia run test.js
 
   test-windows:
@@ -31,4 +33,3 @@ jobs:
       - uses: actions/setup-node@v4
       - run: npm ci
       - run: npm lint
-

README.md

@@ -1,4 +1,5 @@
 # spark
+
 SP Retrieval Checker Module
 
 - [Roadmap](https://pl-strflt.notion.site/SPARK-Roadmap-ac729c11c49b409fbec54751d1bc6c8a)
@@ -33,5 +34,4 @@ $ ./release.sh 1.0.0
 
 Use GitHub's changelog feature to fill out the release notes.
 
-Publish the new release and let the CI/CD workflow upload the sources
-to IPFS & IPNS.
+Publish the new release and let the CI/CD workflow upload the sources to IPFS & IPNS.

deps.ts

@@ -8,23 +8,22 @@
 export { encodeHex } from 'https://deno.land/std@0.203.0/encoding/hex.ts'
 export { decodeBase64 } from 'https://deno.land/std@0.203.0/encoding/base64.ts'
 export { decode as decodeVarint } from 'https://deno.land/x/varint@v2.0.0/varint.ts'
-export { retry } from 'https://deno.land/std@0.203.0/async/retry.ts';
-
+export { retry } from 'https://deno.land/std@0.203.0/async/retry.ts'
 
 // Deno Bundle does not support npm dependencies, we have to load them via CDN
-export { ethers } from "https://cdn.jsdelivr.net/npm/ethers@6.13.5/dist/ethers.min.js";
+export { ethers } from 'https://cdn.jsdelivr.net/npm/ethers@6.13.5/dist/ethers.min.js'
 export { CarBlockIterator } from 'https://cdn.skypack.dev/@ipld/car@5.3.2/?dts'
 export {
   UnsupportedHashError,
   HashMismatchError,
-  validateBlock
+  validateBlock,
 } from 'https://cdn.skypack.dev/@web3-storage/car-block-validator@1.2.0/?dts'
 // cdn.skypack.dev cannot resolve import from @noble/hashes
 // jsdelivr.net seems to work better, it's also recommended by drand-client
 export {
   fetchBeaconByTime,
   HttpChainClient,
-  HttpCachingChain
+  HttpCachingChain,
 } from 'https://cdn.jsdelivr.net/npm/drand-client@1.2.6/index.js/+esm'
 
 export { assertOkResponse } from 'https://cdn.skypack.dev/assert-ok-response@1.0.0/?dts'

lib/activity-state.js

@@ -4,18 +4,18 @@
 export class ActivityState {
   #healthy = null
 
-  onOutdatedClient () {
+  onOutdatedClient() {
     this.onError('SPARK is outdated. Please upgrade Filecoin Station to the latest version.')
   }
 
-  onError (msg) {
+  onError(msg) {
     if (this.#healthy === null || this.#healthy) {
       this.#healthy = false
       Zinnia.activity.error(msg ?? 'SPARK failed reporting retrieval')
     }
   }
 
-  onHealthy () {
+  onHealthy() {
     if (this.#healthy === null) {
       this.#healthy = true
       Zinnia.activity.info('SPARK started reporting retrievals')

lib/drand-client.js

@@ -1,8 +1,4 @@
-import {
-  fetchBeaconByTime,
-  HttpChainClient,
-  HttpCachingChain
-} from '../vendor/deno-deps.js'
+import { fetchBeaconByTime, HttpChainClient, HttpCachingChain } from '../vendor/deno-deps.js'
 
 // See https://docs.filecoin.io/networks/mainnet#genesis
 const FIL_MAINNET_GENESIS_TS = new Date('2020-08-24T22:00:00Z').getTime()
@@ -18,8 +14,9 @@ const DRAND_OPTIONS = {
   chainVerificationParams: {
     // quicknet
     chainHash: '52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971',
-    publicKey: '83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a'
-  }
+    publicKey:
+      '83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809bd274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a',
+  },
 }
 
 const DRAND_URL = `https://api2.drand.sh/${DRAND_OPTIONS.chainVerificationParams.chainHash}`
@@ -29,7 +26,7 @@ const client = new HttpChainClient(chain, DRAND_OPTIONS)
 /**
  * @param {number} roundStartEpoch
  */
-export async function getRandomnessForSparkRound (roundStartEpoch) {
+export async function getRandomnessForSparkRound(roundStartEpoch) {
   const roundStartedAt = roundStartEpoch * FIL_MAINNET_BLOCK_TIME + FIL_MAINNET_GENESIS_TS
   const beacon = await fetchBeaconByTime(client, roundStartedAt)
   return beacon.randomness

lib/http-assertions.js

@@ -6,13 +6,14 @@ export { assertOkResponse } from '../vendor/deno-deps.js'
  * @param {Response} res
  * @param {string} [errorMsg]
  */
-export async function assertRedirectResponse (res, errorMsg) {
+export async function assertRedirectResponse(res, errorMsg) {
   if ([301, 302, 303, 304, 307, 308].includes(res.status)) {
     const location = res.headers.get('location')
     if (!location) {
-      const msg = (errorMsg ? errorMsg + ' ' : '') +
+      const msg =
+        (errorMsg ? errorMsg + ' ' : '') +
         'The server response is missing the Location header. Headers found:\n' +
-         Array.from(res.headers.keys()).join('\n')
+        Array.from(res.headers.keys()).join('\n')
       throw new AssertionError(msg)
     }
     return
@@ -22,7 +23,9 @@ export async function assertRedirectResponse (res, errorMsg) {
   try {
     body = await res.text()
   } catch {}
-  const err = new Error(`${errorMsg ?? 'Server did not respond with redirect'} (${res.status}): ${body?.trimEnd()}`)
+  const err = new Error(
+    `${errorMsg ?? 'Server did not respond with redirect'} (${res.status}): ${body?.trimEnd()}`,
+  )
   err.statusCode = res.status
   err.serverMessage = body
   throw err

lib/ipni-client.js

@@ -9,7 +9,7 @@ import { decodeBase64, decodeVarint, pRetry, assertOkResponse } from '../vendor/
  *  provider?: { address: string; protocol: string };
  * }>}
  */
-export async function queryTheIndex (cid, providerId) {
+export async function queryTheIndex(cid, providerId) {
   let providerResults
   try {
     providerResults = await pRetry(() => getRetrievalProviders(cid), {
@@ -20,13 +20,13 @@ export async function queryTheIndex (cid, providerId) {
       onFailedAttempt: (error) => {
         console.error(error)
         console.error('IPNI query failed, retrying...')
-      }
+      },
     })
     console.log('IPNI returned %s provider results', providerResults.length)
   } catch (err) {
     console.error('IPNI query failed.', err)
     return {
-      indexerResult: typeof err.statusCode === 'number' ? `ERROR_${err.statusCode}` : 'ERROR_FETCH'
+      indexerResult: typeof err.statusCode === 'number' ? `ERROR_${err.statusCode}` : 'ERROR_FETCH',
     }
   }
 
@@ -39,7 +39,7 @@ export async function queryTheIndex (cid, providerId) {
       0x900: 'bitswap',
       0x910: 'graphsync',
       0x0920: 'http',
-      4128768: 'graphsync'
+      4128768: 'graphsync',
     }[protocolCode]
 
     const address = p.Provider.Addrs[0]
@@ -49,14 +49,14 @@ export async function queryTheIndex (cid, providerId) {
       case 'http':
         return {
           indexerResult: 'OK',
-          provider: { address, protocol }
+          provider: { address, protocol },
         }
 
       case 'graphsync':
         if (!graphsyncProvider) {
           graphsyncProvider = {
             address: `${address}/p2p/${p.Provider.ID}`,
-            protocol
+            protocol,
           }
         }
     }
@@ -65,15 +65,15 @@ export async function queryTheIndex (cid, providerId) {
     console.log('HTTP protocol is not advertised, falling back to Graphsync.')
     return {
       indexerResult: 'HTTP_NOT_ADVERTISED',
-      provider: graphsyncProvider
+      provider: graphsyncProvider,
     }
   }
 
   console.log('All advertisements are from other miners or for unsupported protocols.')
   return { indexerResult: 'NO_VALID_ADVERTISEMENT' }
 }
 
-async function getRetrievalProviders (cid) {
+async function getRetrievalProviders(cid) {
   const url = `https://cid.contact/cid/${encodeURIComponent(cid)}`
   const res = await fetch(url)
   await assertOkResponse(res)

lib/miner-info.js

@@ -8,15 +8,15 @@ import { getIndexProviderPeerIdFromSmartContract } from './smart-contract-client
  * @param {function} [options.rpcFn]
  * @returns {Promise<string>} The chain head Cid
  */
-async function getChainHead ({ maxAttempts = 5, rpcFn } = {}) {
+async function getChainHead({ maxAttempts = 5, rpcFn } = {}) {
   try {
     const res = await retry(() => (rpcFn ?? rpc)('Filecoin.ChainHead'), {
       // The maximum amount of attempts until failure.
       maxAttempts,
       // The initial and minimum amount of milliseconds between attempts.
       minTimeout: 5_000,
       // How much to backoff after each retry.
-      multiplier: 1.5
+      multiplier: 1.5,
     })
     return res.Cids
   } catch (err) {
@@ -35,12 +35,15 @@ async function getChainHead ({ maxAttempts = 5, rpcFn } = {}) {
  * @param {number} [options.maxAttempts]
  * @returns {Promise<string>} Miner's PeerId, e.g. `12D3KooWMsPmAA65yHAHgbxgh7CPkEctJHZMeM3rAvoW8CZKxtpG`
  */
-export async function getIndexProviderPeerId (minerId, { maxAttempts = 5, smartContract, rpcFn } = {}) {
+export async function getIndexProviderPeerId(
+  minerId,
+  { maxAttempts = 5, smartContract, rpcFn } = {},
+) {
   try {
-  // Make a concurrent request to both sources: FilecoinMinerInfo and smart contract
+    // Make a concurrent request to both sources: FilecoinMinerInfo and smart contract
     const [minerInfoResult, contractResult] = await Promise.all([
       getIndexProviderPeerIdFromFilecoinMinerInfo(minerId, { maxAttempts, rpcFn }),
-      getIndexProviderPeerIdFromSmartContract(minerId, { smartContract })
+      getIndexProviderPeerIdFromSmartContract(minerId, { smartContract }),
     ])
     // Check contract result first
     if (contractResult) {
@@ -55,11 +58,13 @@ export async function getIndexProviderPeerId (minerId, { maxAttempts = 5, smartC
     }
 
     // Handle the case where both failed
-    throw new Error(`Failed to obtain Miner's Index Provider PeerID.\nSmartContract query result: ${contractResult}\nStateMinerInfo query result: ${minerInfoResult}`)
+    throw new Error(
+      `Failed to obtain Miner's Index Provider PeerID.\nSmartContract query result: ${contractResult}\nStateMinerInfo query result: ${minerInfoResult}`,
+    )
   } catch (error) {
     console.error('Error fetching PeerID:', error)
     throw Error(`Error fetching PeerID for miner ${minerId}.`, {
-      cause: error
+      cause: error,
     })
   }
 }
@@ -71,7 +76,10 @@ export async function getIndexProviderPeerId (minerId, { maxAttempts = 5, smartC
  * @param {function} [options.rpcFn]
  * @returns {Promise<string>} Miner's PeerId, e.g. `12D3KooWMsPmAA65yHAHgbxgh7CPkEctJHZMeM3rAvoW8CZKxtpG`
  */
-export async function getIndexProviderPeerIdFromFilecoinMinerInfo (minerId, { maxAttempts = 5, rpcFn } = {}) {
+export async function getIndexProviderPeerIdFromFilecoinMinerInfo(
+  minerId,
+  { maxAttempts = 5, rpcFn } = {},
+) {
   const chainHead = await getChainHead({ maxAttempts, rpcFn })
   try {
     const res = await retry(() => (rpcFn ?? rpc)('Filecoin.StateMinerInfo', minerId, chainHead), {
@@ -80,7 +88,7 @@ export async function getIndexProviderPeerIdFromFilecoinMinerInfo (minerId, { ma
       // The initial and minimum amount of milliseconds between attempts.
       minTimeout: 5_000,
       // How much to backoff after each retry.
-      multiplier: 1.5
+      multiplier: 1.5,
     })
     return res.PeerId
   } catch (err) {
@@ -97,23 +105,23 @@ export async function getIndexProviderPeerIdFromFilecoinMinerInfo (minerId, { ma
  * @param {string} method
  * @param {unknown[]} params
  */
-async function rpc (method, ...params) {
+async function rpc(method, ...params) {
   const req = new Request(RPC_URL, {
     method: 'POST',
     headers: {
       'content-type': 'application/json',
       accepts: 'application/json',
-      authorization: `Bearer ${RPC_AUTH}`
+      authorization: `Bearer ${RPC_AUTH}`,
     },
     body: JSON.stringify({
       jsonrpc: '2.0',
       id: 1,
       method,
-      params
-    })
+      params,
+    }),
   })
   const res = await fetch(req, {
-    signal: AbortSignal.timeout(60_000)
+    signal: AbortSignal.timeout(60_000),
   })
 
   if (!res.ok) {

lib/multiaddr.js

@@ -2,48 +2,46 @@
  * @param {string} addr Multiaddr, e.g. `/ip4/127.0.0.1/tcp/80/http`
  * @returns {string} Parsed URI, e.g. `http://127.0.0.1:80`
  */
-export function multiaddrToHttpUrl (addr) {
+export function multiaddrToHttpUrl(addr) {
   const [multiAddr, httpPathMultiAddr] = addr.split('/http-path')
   const [, hostType, hostValue, ...multiAddrParts] = multiAddr.split('/')
   let scheme, path, rest, port
   if (addr.includes('/http-path')) {
-    [scheme, ...rest] = multiAddrParts
+    ;[scheme, ...rest] = multiAddrParts
     try {
       // Remove leading slash and parse URI-encoded path
       // See https://github.com/multiformats/multiaddr/blob/cab92e8e6da2e70c5f1b8aa59976e71e6922b392/protocols/http-path.md#usage
       path = decodeURIComponent(httpPathMultiAddr.substring(1))
     } catch (err) {
       throw Object.assign(
         new Error(`Cannot parse "${addr}": unsupported http path`, { cause: err }),
-        { code: 'INVALID_HTTP_PATH' }
+        { code: 'INVALID_HTTP_PATH' },
       )
     } // Handle HTTP/HTTPs addresses using the default port
   } else if (multiAddrParts[0] === 'http' || multiAddrParts[0] === 'https') {
-    [scheme, ...rest] = multiAddrParts
+    ;[scheme, ...rest] = multiAddrParts
   } else {
     let ipProtocol
     ;[ipProtocol, port, scheme, ...rest] = multiAddrParts
 
     if (ipProtocol !== 'tcp') {
       throw Object.assign(
         new Error(`Cannot parse "${addr}": unsupported protocol "${ipProtocol}"`),
-        { code: 'UNSUPPORTED_MULTIADDR_PROTO' }
+        { code: 'UNSUPPORTED_MULTIADDR_PROTO' },
       )
     }
   }
 
   if (scheme !== 'http' && scheme !== 'https') {
-    throw Object.assign(
-      new Error(`Cannot parse "${addr}": unsupported scheme "${scheme}"`),
-      { code: 'UNSUPPORTED_MULTIADDR_SCHEME' }
-    )
+    throw Object.assign(new Error(`Cannot parse "${addr}": unsupported scheme "${scheme}"`), {
+      code: 'UNSUPPORTED_MULTIADDR_SCHEME',
+    })
   }
 
   if (rest.length) {
-    throw Object.assign(
-      new Error(`Cannot parse "${addr}": too many parts`),
-      { code: 'MULTIADDR_HAS_TOO_MANY_PARTS' }
-    )
+    throw Object.assign(new Error(`Cannot parse "${addr}": too many parts`), {
+      code: 'MULTIADDR_HAS_TOO_MANY_PARTS',
+    })
   }
 
   let url = `${scheme}://${getUriHost(hostType, hostValue)}`
@@ -52,7 +50,7 @@ export function multiaddrToHttpUrl (addr) {
   return url
 }
 
-function getUriHost (hostType, hostValue) {
+function getUriHost(hostType, hostValue) {
   switch (hostType) {
     case 'ip4':
     case 'dns':
@@ -65,13 +63,12 @@ function getUriHost (hostType, hostValue) {
       return `[${hostValue}]`
   }
 
-  throw Object.assign(
-    new Error(`Unsupported multiaddr host type "${hostType}"`),
-    { code: 'UNSUPPORTED_MULTIADDR_HOST_TYPE' }
-  )
+  throw Object.assign(new Error(`Unsupported multiaddr host type "${hostType}"`), {
+    code: 'UNSUPPORTED_MULTIADDR_HOST_TYPE',
+  })
 }
 
-function getUriPort (scheme, port) {
+function getUriPort(scheme, port) {
   if (scheme === 'http' && port === '80') return ''
   if (scheme === 'https' && port === '443') return ''
   return `:${port}`