allCCProviders = [...(await FileAttachment("allCCProviders.json").json())].sort()
x = (await client.stateGetActor('f0127595', tipSetKey))
y = (await client.stateMinerInfo('f0127595', tipSetKey))
minerData = {
const owners = new Set()
let count = 0
let totalMinerBalance = 0n
for (const minerId of allCCProviders) {
count++
console.log('Jim', minerId)
const minerActor = (await client.stateGetActor(minerId, tipSetKey))
const minerInfo = (await client.stateMinerInfo(minerId, tipSetKey))
owners.add(minerInfo.Owner)
totalMinerBalance += BigInt(minerActor.Balance)
yield {
count,
minerId,
totalMinerBalance,
owners
}
}
}
ownerData = {
let count = 0
let totalOwnerBalance = 0n
const ownersSorted = [...owners].sort()
for (const address of ownersSorted) {
count++
const actor = (await client.stateGetActor(address, tipSetKey))
totalOwnerBalance += BigInt(actor.Balance)
yield {
count,
address,
totalOwnerBalance
}
}
}
filecoinNumber = import('https://cdn.skypack.dev/pin/@glif/filecoin-number@v2.0.0-beta.0-iQnBkhznGjB3HsyiyYB8/mode=imports,min/optimized/@glif/filecoin-number.js')
FilecoinNumber = filecoinNumber.FilecoinNumber
totalMinerBalance = Number(new FilecoinNumber(minerData.totalMinerBalance, 'attofil').toFil())
totalOwnerBalance = Number(new FilecoinNumber(ownerData.totalOwnerBalance, 'attofil').toFil())
totalMinerPlusOwnerBalance = totalMinerBalance + totalOwnerBalance
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(), 7)
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')).transform
import { epochToDate } from '@jbenet/filecoin-chain-time-calculator'
bytes = (await import('@jimpick/bytes-iec@3.1.0-2')).default
d3 = require("d3@6")
One platform to build and deploy the best data apps
Experiment and prototype by building visualizations in live JavaScript notebooks. Collaborate with your team and decide which concepts to build out.
Use Observable Framework to build data apps locally. Use data loaders to build in any language or library, including Python, SQL, and R.
Seamlessly deploy to Observable. Test before you ship, use automatic deploy-on-commit, and ensure your projects are always up-to-date.