ETH Burned

1export const name = 'ETH Burned';
2export const version = '0.2.2';
3export const license = 'MIT';
4export const description = 'Queries metrics regarding the ETH burned by EIP-1559';
5
6// https://thegraph.com/explorer/subgraph?id=J2RS1vzH8LnfR4XV8kEv6ZNyRyWSbwjqQ4i1zdgsf1TB
7const subgraphId = 'J2RS1vzH8LnfR4XV8kEv6ZNyRyWSbwjqQ4i1zdgsf1TB';
8
9export function setup(sdk: Context) {
10  const getCurrentIndexedBlock = async () => {
11    const query = `{
12      _meta {
13        block {
14          number
15        }
16      }
17    }`;
18    const data = await sdk.graph.query({ subgraphId, query });
19    return parseInt(data._meta.block.number);
20  };
21
22  const burnedOnDateRange = async (field: string, dateStart: string, dateEnd: string): Promise<number> => {
23    const startOfDayBlock = await sdk.chainData.getBlockNumber(dateStart, 'ethereum');
24    const endOfDayBlock = await sdk.chainData.getBlockNumber(dateEnd, 'ethereum');
25
26    const query = `query ethBurned{
27        startOfDay: ethburned(id: "1", block: {number: ${startOfDayBlock}}) {
28          ${field}
29        }
30        endOfDay: ethburned(id: "1", block: {number: ${endOfDayBlock}}) {
31          ${field}
32        }
33      }`
34
35    const data = await sdk.graph.query({ subgraphId, query });
36
37    const ethBurned = parseFloat(data.endOfDay[field]) - parseFloat(data.startOfDay[field]);
38
39    return ethBurned;
40  }
41
42  const getBurnedOnDate = (field: string) =>
43    (date: string) => burnedOnDateRange(field, date, sdk.date.offsetDaysFormatted(date, 1));
44
45  const getBurnedOnDateRange = (field: string) =>
46    (dateStart: string, dateEnd: string) => burnedOnDateRange(field, dateStart, dateEnd);
47
48  const getBurnedTotal = (field: string) => async () => {
49    const query = `{
50      ethburned(id: "1") {
51        ${field}
52      }
53    }`;
54    const data = await sdk.graph.query({ subgraphId, query });
55
56    return parseFloat(data.ethburned[field]);
57  }
58
59  const getBurnedOnRecentBlocks = async (numBlocks: number) => {
60    const currentBlock = await getCurrentIndexedBlock();
61
62    const burnQueries = [];
63    for (let block = currentBlock - numBlocks; block <= currentBlock; block += 1) {
64      burnQueries.push(`block_${block}: ethburned(id: "1", block: { number: ${block} }) { burned }`);
65    }
66
67    const query = `{ ${burnQueries.join('\n')} }`;
68    const burnQuery = await sdk.graph.query({ subgraphId, query });
69
70    const dataQuery = sdk.graph.query(
71      'blocklytics/ethereum-blocks',
72      `query ($startBlock: Int!, $endBlock: Int!){
73        blocks(where: {number_gte: $startBlock, number_lte: $endBlock }, orderBy: number) {
74          number
75          timestamp
76        }
77      }`,
78      {
79        variables: {
80          startBlock: currentBlock - numBlocks,
81          endBlock: currentBlock,
82        },
83      }
84    );
85
86    const [result, dateResults] = await Promise.all([burnQuery, dataQuery]);
87
88    const burnedOnBlock: { block: number; burned: number; timestamp: number }[] = [];
89    for (let i = 0; i <= 30; i += 1) {
90      if (!dateResults.blocks[i]) {
91        break;
92      }
93
94      const block = currentBlock - 30 + i;
95
96      if (!result[`block_${block}`]) {
97        continue;
98      }
99      burnedOnBlock.push({
100        block,
101        burned: parseFloat(result[`block_${block}`].burned),
102        timestamp: parseInt(dateResults.blocks[i].timestamp),
103      });
104    }
105
106    return burnedOnBlock;
107  };
108
109  const getBurnedInRecentTimePeriod = async (period: string, numPeriods: number) => {
110    if (['minute', 'hour', 'day'].indexOf(period) === -1) {
111      throw new Error(`Invalid period ${period}`);
112    }
113
114    const date = new Date();
115    let periodLength: number;
116    if (period === 'day') {
117      date.setHours(0, 0, 0, 0);
118      periodLength = 24 * 60 * 60;
119    } else if (period === 'hour') {
120      date.setMinutes(0, 0, 0);
121      periodLength = 60 * 60;
122    } else {
123      // minute
124      date.setSeconds(0, 0);
125      periodLength = 60;
126    }
127
128    const blockQueries = [];
129    const timestamps = [];
130    for (let i = 0; i < numPeriods; i += 1) {
131      const timestamp = date.getTime() / 1000 - periodLength * i;
132      timestamps.push(timestamp);
133      blockQueries.push(`block_${i}: blocks(where: {
134        timestamp_gte: ${timestamp},
135        timestamp_lte: ${timestamp + 100}
136      }, orderBy: number, limit: 1) {
137        number
138      }`);
139    }
140    const blockResult = await sdk.graph.query(
141      'blocklytics/ethereum-blocks',
142      `{${blockQueries.join('\n')}}`
143    );
144
145    const blocks = [];
146    const burnQueries = [];
147    for (let i = 0; i < numPeriods; i += 1) {
148      if (blockResult[`block_${i}`].length === 0) {
149        blocks.push(0);
150        continue;
151      }
152
153      const blockNum = blockResult[`block_${i}`][0].number;
154      blocks.push(parseInt(blockNum));
155      burnQueries.push(`burned_${i}: ethburned(id:"1", block: { number: ${blockNum} }){ burned }`);
156    }
157
158    burnQueries.push('now: ethburned(id:"1") { burned }');
159    burnQueries.push('_meta { block { number } }');
160
161    const burnResult = await sdk.graph.query({ subgraphId, query: `{${burnQueries.join('\n')}}` });
162
163    const response = [
164      {
165        burned: parseFloat(burnResult.now.burned),
166        timestamp: Math.floor(Date.now() / 1000),
167        block: parseInt(burnResult._meta.block.number),
168      },
169    ];
170    for (let i = 0; i < numPeriods; i += 1) {
171      if (blocks[i] === 0) {
172        continue;
173      }
174
175      response.push({
176        burned: parseFloat(burnResult[`burned_${i}`]?.burned || '0'),
177        timestamp: timestamps[i],
178        block: blocks[i],
179      });
180    }
181
182    return response.reverse();
183  };
184
185  const getBurnedInRecentSeconds = (field: string) => async (seconds: number) => {
186    const start = new Date().getTime() - (seconds * 1000);
187    const startBlock = await sdk.chainData.getBlockNumber(start, 'ethereum');
188
189    const query = `query {
190      now: ethburned(id:"1") {
191        burned
192        burnedUSD
193      }
194      start: ethburned(id:"1", block: { number: ${startBlock} }) {
195        burned
196        burnedUSD
197      }
198    }`;
199
200    const result = await sdk.graph.query({ subgraphId, query });
201
202    if (!result.start) {
203      return parseFloat(result.now[field]);
204    }
205
206    return result.now[field] - result.start[field];
207  }
208
209  sdk.register({
210    id: 'eth-burned',
211    queries: {
212      tokensBurnedTotal: getBurnedTotal('burned'),
213      tokensBurnedTotalUSD: getBurnedTotal('burnedUSD'),
214      tokensBurnedOnDay: getBurnedOnDate('burned'),
215      tokensBurnedOnDayUSD: getBurnedOnDate('burnedUSD'),
216      tokensBurnedOnDateRange: getBurnedOnDateRange('burned'),
217      tokensBurnedOnDateRangeUSD: getBurnedOnDateRange('burnedUSD'),
218      tokensBurnedInRecentBlocks: getBurnedOnRecentBlocks,
219      tokensBurnedInRecentSeconds: getBurnedInRecentSeconds('burned'),
220      tokensBurnedInRecentSecondsUSD: getBurnedInRecentSeconds('burnedUSD'),
221      tokensBurnedInRecentTimePeriods: getBurnedInRecentTimePeriod,
222      currentIndexedBlock: getCurrentIndexedBlock,
223    },
224    metadata: {
225      name: 'ETH Burned',
226      icon: sdk.ipfs.getDataURILoader('QmedJLPy6R7x3dDEy2cfMd8gXbZm9e3vxvgBLXp3YZEHCy', 'image/svg+xml'),
227    },
228  })
229}
230