Public
Edited
Sep 21, 2023
4 forks
await client.version()
chainHead = await client.chainHead()
viewof interactiveEpoch = html`<input type=range min=${currentEpoch - 5000} max=${currentEpoch} value=${currentEpoch - 1} style="width: 100%">`
selectedEpoch = {
// return 142500
return interactiveEpoch
}
selectedDate = epochToDate(selectedEpoch).toISOString()
tipSet = [...tipSetKey].map(obj => obj['/']).sort().join(',')
minerCount = selectedMinerIndexes.length
maxElapsed = 10 * 60 * 1000
minTimestamp = dateFns.subDays(new Date(), 14)
allMiners = (await client.stateListMiners(tipSetKey)).sort(sortMiners)
sortMiners = function (a, b) { return Number(a.slice(1)) - Number(b.slice(1)) }
allMiners.slice(-5)
import { annotatedMinerIndexes } from '@jimpick/provider-quest-feeds'
// annotatedMinerIndexes
selectedMinerIndexes = {
let miners = []
const recentMinerSet = new Set()
const recentAveragesMinerSet = new Set()
for (const miner of Object.keys(minerPowerLatestReport.miners)) {
if (d3.isoParse(minerPowerLatestReport.miners[miner].timestamp) > minTimestamp) {
recentMinerSet.add(miner)
recentAveragesMinerSet.add(miner)
}
}
for (const miner of Object.keys(minerPowerDailyAverageReport.miners)) {
recentAveragesMinerSet.add(miner)
}
for (const miner of Object.keys(minerPowerMultidayAverageReport.miners)) {
recentAveragesMinerSet.add(miner)
}
if (subsetToScan === 'Recents') {
miners = [...recentMinerSet]
} else if (subsetToScan === 'Recents, Averages') {
miners = [...recentAveragesMinerSet]
} else if (subsetToScan === 'Newest miners, not recent') {
miners = allMiners.slice(-10000).filter(miner => !recentMinerSet.has(miner))
} else if (subsetToScan === 'All miners, not recent') {
miners = allMiners.filter(miner => !recentMinerSet.has(miner))
/*
} else if (subsetToScan === 'Legacy annotated') {
miners = annotatedMinerIndexes
*/
} else if (subsetToScan === 'All miners') {
miners = allMiners
}
return d3.shuffle(miners)
}
async function* minerPowerStream() {
const concurrency = 15
const callMinerPowerStream = transform(concurrency, async miner => {
try {
const minerPower = (await client.stateMinerPower(miner, tipSetKey)).MinerPower
console.log('Jim', miner, minerPower.QualityAdjPower)
return {
miner,
rawBytePower: Number(minerPower.RawBytePower),
qualityAdjPower: Number(minerPower.QualityAdjPower)
}
} catch (e) {
console.error('Fetch error', e)
return {}
}
})
const startTime = new Date()
let counter = 0
for await (const { miner, rawBytePower, qualityAdjPower } of callMinerPowerStream(selectedMinerIndexes)) {
const now = new Date()
if (rawBytePower > 0 || qualityAdjPower > 0) {
yield {
counter,
epoch: selectedEpoch,
miner,
rawBytePower,
qualityAdjPower
}
} else {
yield {
counter
}
}
counter++
if (now - startTime > maxElapsed) {
yield {
done: true,
timeout: true,
counter
}
return
}
}
}
// minerPowerStream()
minerPower = {
if (start === 0) {
yield {
state: 'paused'
}
return
}
yield {
state: 'starting'
}
let records = []
const startTime = new Date()
for await (const {counter, ...record} of minerPowerStream()) {
if (record.epoch) {
records.push(record)
}
yield {
state: "streaming",
elapsed: ((new Date()) - startTime) / 1000,
counter,
recordsLength: records.length
}
}
const endTime = new Date()
yield {
state: "done",
elapsed: (endTime - startTime) / 1000,
records,
startTime: startTime.toISOString(),
endTime: endTime.toISOString()
}
}
minerPower.state === 'done' && md`Miner | Raw Byte Power | Quality Adjusted Power
---|---|---
${minerPower.records.sort((a, b) => b.qualityAdjPower - a.qualityAdjPower).slice(0, maxRows).map(({ miner, rawBytePower, qualityAdjPower }) => {
let lines = `${miner} | ${bytes(rawBytePower, { mode: 'binary' })} | ${bytes(qualityAdjPower, { mode: 'binary' })}\n`
return lines
})}
`
maxRows = 50
LotusRPC = (await import('@filecoin-shipyard/lotus-client-rpc')).LotusRPC
BrowserProvider = (await import('@filecoin-shipyard/lotus-client-provider-browser')).BrowserProvider
schema = (await import('@filecoin-shipyard/lotus-client-schema')).mainnet.fullNode
Object.keys(schema.methods)
endpointUrl = {
return "wss://lotus.miner.report/mainnet_api/0/node/rpc/v0"
// return "wss://lotus.jimpick.com/mainnet_api/0/node/rpc/v0"
// return "https://api.node.glif.io/rpc/v0"
}
client = {
const provider = new BrowserProvider(endpointUrl)
return new LotusRPC(provider, { schema })
}
transform = (await import('streaming-iterables@7.1.0')).transform
import { epochToDate } from '@jbenet/filecoin-chain-time-calculator'
bytes = (await import('@jimpick/bytes-iec@3.1.0-2')).default
d3 = require("d3@6")
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
