Public
Edited
Dec 20, 2022
Plot.plot({
y: {
grid: true,
label: "Votes Bps"
},
x: {
label: "Proposal ID"
},
color: {
scheme: "rainbow"
},
marks: [
Plot.barY(governanceData, {x: "id", y: "votesAsBps", fill:"votesAsBps"})
]
})
Plot.plot({
y: {
grid: true,
label: "Votes Surplus Bps"
},
x: {
label: "Proposal ID"
},
color: {
scheme: "rainbow"
},
marks: [
Plot.barY(governanceData, {x: "id", y: "surplusAsBps", fill:"surplusAsBps"})
]
})
governanceData = R.pipe(
R.map(cleanProposal),
R.map(addVotesSum),
R.map(addQuorumSurplus),
R.map(addQuorumSurplusAsBps),
R.map(addSupplyAtStart),
R.map(addVotesAsBps),
)((await axios.post(subgraphUrl, {query: governanceQuery})).data.data.proposals)
addQuorumSurplusAsBps = proposal => ({...proposal, surplusAsBps: (proposal.quorumSurplus / supplyAtBlock(proposal.startBlock))* 10000})
addVotesAsBps = proposal => ({...proposal, votesAsBps: (proposal.votesSum / supplyAtBlock(proposal.startBlock) * 10000)})
addSupplyAtStart = proposal => ({...proposal, supplyAtStart: supplyAtBlock(proposal.startBlock)})
supplyAtBlock = block => (block - FIRST_NOUN_START_BLOCK) / BLOCKS_PER_NOUN
addQuorumSurplus = proposal => ({...proposal, quorumSurplus: proposal.votesSum - proposal.quorumVotes})
addVotesSum = proposal => ({...proposal, votesSum: computeVoteSum(proposal.votes)})
computeVoteSum = R.compose(R.sum, R.map(R.prop('votes')))
cleanProposal = rawProposal => ({
description: rawProposal.description,
endBlock: Number(rawProposal.endBlock),
executionETA: Number(rawProposal.executionETA),
id: Number(rawProposal.id),
proposalThreshold: Number(rawProposal.proposalThreshold),
quorumVotes: Number(rawProposal.quorumVotes),
startBlock: Number(rawProposal.startBlock),
proposer: rawProposal.proposer,
votes: R.map(cleanVote, rawProposal.votes)
})
cleanVote = vote => ({...vote, votes: Number(vote.votes)})
subgraphUrl = "https://api.thegraph.com/subgraphs/name/nounsdao/nouns-subgraph"
governanceData.filter(hadAgainstVote)
hadAgainstVote(lastFiveProposals[6])
hadAgainstVote = proposal => R.any(R.identity, R.map(vote => !vote.support, proposal.votes))
lastFiveProposals = governanceData.slice(0, 99)
Plot.plot({
x: {
label: "Number of Nouns Delegated"
},
y: {
label: "Number of Accounts"
},
color: {
scheme: "rainbow"
},
marks: [
Plot.barY(plottableFrequencyOfDelegatesVotedInN, {x: "delegationCount", y: "freq", fill:"freq"})
]
})
plottableFrequencyOfDelegatesVotedInN = Object.keys(frequencyOfAllDelegates).map(delegationCount => ({delegationCount: Number(delegationCount), freq: frequencyOfAllDelegates[delegationCount]}))
frequencyOfDelegatesVotedInLastFive = Object.keys(delegatesVotedInLastFive).reduce((acc, delegate) => {
if (!acc[delegates[delegate]]) acc[delegates[delegate]] = 0
acc[delegates[delegate]]++
return acc
},{})
frequencyOfAllDelegates = Object.keys(delegates).reduce((acc, delegate) => {
if (!acc[delegates[delegate]]) acc[delegates[delegate]] = 0
acc[delegates[delegate]]++
return acc
},{})
delegatesVotedInLastFive = Object.keys(delegates).filter(delegate => delegateVotedInAnyProposals(lastFiveProposals, delegate)).reduce((acc, delegate) => {
acc[delegate] = delegates[delegate]
return acc;
},{})
delegateVotedInAnyProposals = (proposals, delegate) => R.any(R.identity, R.map(p => delegateVotedInProposal(p, delegate), proposals))
delegateVotedInProposal = (proposal, delegate) => proposalVoters(proposal).includes(delegate)
proposalVoters = proposal => R.map(R.pipe(R.prop('id'), addr => addr.split('-')[0]), proposal.votes)
| Votes Delegated | Addresses |
|---|---|
${Object.keys(delegateSet).map(count => `|${count}|${delegateSet[count].join(', ')}\n`)}
delegateSet = delegateCounts.filter(deleg => deleg.count > 1).reduce((acc, delegation) => {
if(!acc[delegation.count]) acc[delegation.count] = [];
acc[delegation.count].push(delegation.addr)
return acc
}, {})
delegateCounts = Object.keys(delegates).map(addr => ({addr, count: delegates[addr]})).sort((a, b) => b.count - a.count)
nouns = R.pipe(
R.map(normalizeNoun)
)((await axios.post(subgraphUrl, {query: nounsQuery})).data.data.nouns).sort((a, b) => a.id - b.id)
normalizeSeed = (seed) => ({
accessory: Number(seed.accessory),
background: Number(seed.background),
body: Number(seed.body),
glasses: Number(seed.glasses),
head: Number(seed.head),
});
normalizeNoun = (noun) => ({
...noun,
id: Number(noun.id),
seed: normalizeSeed(noun.seed),
});
FIRST_NOUN_START_BLOCK=12985732
BLOCKS_PER_NOUN = (13700622 - FIRST_NOUN_START_BLOCK) / 123
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.
