ETH Burned

1export const name = 'ETH Burned';
2export const version = '0.2.1';
3export const license = 'MIT';
4
5const SUBGRAPH = 'dmihal/eth-burned';
6
7export function setup(sdk: Context) {
8  const getCurrentIndexedBlock = async () => {
9    const data = await sdk.graph.query(SUBGRAPH, `{
10      _meta {
11        block {
12          number
13        }
14      }
15    }`);
16    return parseInt(data._meta.block.number);
17  };
18
19  const burnedOnDateRange = async (field: string, dateStart: string, dateEnd: string): Promise<number> => {
20    const startOfDayBlock = await sdk.chainData.getBlockNumber(dateStart, 'ethereum');
21    const endOfDayBlock = await sdk.chainData.getBlockNumber(dateEnd, 'ethereum');
22
23    const variables = {
24      startOfDay: startOfDayBlock,
25      endOfDay: endOfDayBlock,
26    };
27
28    const query = `query ethBurned($startOfDay: Int!, $endOfDay: Int!){
29        startOfDay: ethburned(id: "1", block: {number: $startOfDay}) {
30          ${field}
31        }
32        endOfDay: ethburned(id: "1", block: {number: $endOfDay}) {
33          ${field}
34        }
35      }`
36
37    const data = await sdk.graph.query(SUBGRAPH, query, { variables });
38
39    const ethBurned = parseFloat(data.endOfDay[field]) - parseFloat(data.startOfDay[field]);
40
41    return ethBurned;
42  }
43
44  const getBurnedOnDate = (field: string) =>
45    (date: string) => burnedOnDateRange(field, date, sdk.date.offsetDaysFormatted(date, 1));
46
47  const getBurnedOnDateRange = (field: string) =>
48    (dateStart: string, dateEnd: string) => burnedOnDateRange(field, dateStart, dateEnd);
49
50  const getBurnedTotal = (field: string) => async () => {
51    const data = await sdk.graph.query(SUBGRAPH, `{
52      ethburned(id: "1") {
53        ${field}
54      }
55    }`);
56
57    return parseFloat(data.ethburned[field]);
58  }
59
60  const getBurnedOnRecentBlocks = async (numBlocks: number) => {
61    const currentBlock = await getCurrentIndexedBlock();
62
63    const burnQueries = [];
64    for (let block = currentBlock - numBlocks; block <= currentBlock; block += 1) {
65      burnQueries.push(`block_${block}: ethburned(id: "1", block: { number: ${block} }) { burned }`);
66    }
67
68    const burnQuery = sdk.graph.query(SUBGRAPH, `{${burnQueries.join('\n')}}`);
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(SUBGRAPH, `{${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 result = await sdk.graph.query(
190      SUBGRAPH,
191      `query ($startBlock: Int!){
192      now: ethburned(id:"1") {
193        burned
194        burnedUSD
195      }
196      start: ethburned(id:"1", block: { number: $startBlock }) {
197        burned
198        burnedUSD
199      }
200    }`,
201      {
202        variables: { startBlock },
203      }
204    );
205
206    if (!result.start) {
207      return parseFloat(result.now[field]);
208    }
209
210    return result.now[field] - result.start[field];
211  }
212
213  sdk.register({
214    id: 'eth-burned',
215    queries: {
216      tokensBurnedTotal: getBurnedTotal('burned'),
217      tokensBurnedTotalUSD: getBurnedTotal('burnedUSD'),
218      tokensBurnedOnDay: getBurnedOnDate('burned'),
219      tokensBurnedOnDayUSD: getBurnedOnDate('burnedUSD'),
220      tokensBurnedOnDateRange: getBurnedOnDateRange('burned'),
221      tokensBurnedOnDateRangeUSD: getBurnedOnDateRange('burnedUSD'),
222      tokensBurnedInRecentBlocks: getBurnedOnRecentBlocks,
223      tokensBurnedInRecentSeconds: getBurnedInRecentSeconds('burned'),
224      tokensBurnedInRecentSecondsUSD: getBurnedInRecentSeconds('burnedUSD'),
225      tokensBurnedInRecentTimePeriods: getBurnedInRecentTimePeriod,
226      currentIndexedBlock: getCurrentIndexedBlock,
227    },
228    metadata: {
229      name: 'ETH Burned',
230      icon: sdk.ipfs.getDataURILoader('QmedJLPy6R7x3dDEy2cfMd8gXbZm9e3vxvgBLXp3YZEHCy', 'image/svg+xml'),
231    },
232  })
233}
234