-
Notifications
You must be signed in to change notification settings - Fork 99
/
index.js
316 lines (279 loc) Β· 9.93 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
const path = require('path')
const exec = require('child_process').exec
const nearAPI = require('near-api-js')
const BN = require('bn.js')
const { serialize } = require('../../utils/borsh')
const {
RobustWeb3,
sleep
} = require('rainbow-bridge-utils')
const {
web3BlockToRlp,
EthOnNearClientContract,
borshSchema,
getEthBlock,
dagMerkleRoots
} = require('./eth-on-near-client')
const {
EthOnNearProverContract
} = require('./eth-on-near-prover')
const {
EthProofExtractor,
logFromWeb3,
receiptFromWeb3,
ethToNearFindProof,
ethToNearFindStorageProof
} = require('./eth-proof-extractor')
const {
HttpPrometheus
} = require('../../utils/http-prometheus.js')
const BRIDGE_SRC_DIR = path.join(__dirname, '..', '..')
const MAX_GAS_PER_BLOCK = '300000000000000'
function ethashproof (command, _callback) {
return new Promise((resolve) =>
exec(command, (error, stdout, stderr) => {
if (error) {
console.error(error)
}
if (stderr) {
console.error(stderr)
}
resolve(stdout)
})
)
}
// This function find the result in O(log delta) where delta is the difference between estimatedPosition and the result.
// In particular if estimatedPosition is the correct value it will make two calls to predicate, so it will behave in O(1) in this case.
async function binarySearchWithEstimate (limitLo, limitHi, estimatedPosition, predicate) {
let lo = limitLo
let hi = limitHi
const value = await predicate(estimatedPosition)
if (value) {
hi = estimatedPosition
let step = 1
while (hi - step > lo && await predicate(hi - step)) {
step *= 2
}
hi -= Math.floor(step / 2)
lo = Math.max(lo, hi - step)
} else {
lo = estimatedPosition
let step = 1
while (lo + step < hi && !await predicate(lo + step)) {
step *= 2
}
lo += Math.floor(step / 2)
hi = Math.min(hi, lo + step)
}
while (lo + 1 < hi) {
const mid = Math.floor((lo + hi) / 2)
if (await predicate(mid)) {
hi = mid
} else {
lo = mid
}
}
return hi
}
const NUM_OF_BLOCKS_PER_EPOCH = 30000
const NUM_OF_BLOCKS_TO_END_OF_EPOCH = 5000
class Ethashproof {
constructor () {
this.nextEpochPromise = null
this.nextEpoch = null
}
async getParseBlock (blockNumber, blockRlp) {
const currentEpoch = Math.trunc(blockNumber / NUM_OF_BLOCKS_PER_EPOCH)
const remBlocksToEndOfEpoch = NUM_OF_BLOCKS_PER_EPOCH - (blockNumber % NUM_OF_BLOCKS_PER_EPOCH)
if (this.nextEpoch === currentEpoch && this.nextEpochPromise != null) {
await this.nextEpochPromise
}
const result = await ethashproof(
`${BRIDGE_SRC_DIR}/eth2near/ethashproof/cmd/relayer/relayer ${blockRlp} | sed -e '1,/Json output/d'`
)
const nextEpoch = currentEpoch + 1
if (this.nextEpoch !== nextEpoch && remBlocksToEndOfEpoch < NUM_OF_BLOCKS_TO_END_OF_EPOCH) {
this.calculateNextEpoch(nextEpoch)
}
return result
}
calculateNextEpoch (nextEpoch) {
this.nextEpoch = nextEpoch
this.nextEpochPromise = ethashproof(
`${BRIDGE_SRC_DIR}/eth2near/ethashproof/cmd/cache/cache ${nextEpoch}`
)
}
}
class Eth2NearRelay {
initialize (ethClientContract, {
ethNodeUrl,
totalSubmitBlock,
gasPerTransaction,
nearNetworkId,
metricsPort
}) {
this.ethashproof = new Ethashproof()
this.gasPerTransaction = new BN(gasPerTransaction)
const limitSubmitBlock = new BN(MAX_GAS_PER_BLOCK).div(this.gasPerTransaction).toNumber()
this.totalSubmitBlock = parseInt(totalSubmitBlock)
if (Number.isNaN(this.totalSubmitBlock)) {
throw new Error(`Invalid total-submit-block (${totalSubmitBlock})`)
}
if (this.totalSubmitBlock > limitSubmitBlock) {
throw new Error(`total-submit-block must be ${limitSubmitBlock} or less. Currently it is: ${this.totalSubmitBlock}`)
}
this.bridgeId = nearNetworkId
this.ethClientContract = ethClientContract
this.robustWeb3 = new RobustWeb3(ethNodeUrl)
this.web3 = this.robustWeb3.web3
this.metricsPort = metricsPort
}
async run () {
const robustWeb3 = this.robustWeb3
const httpPrometheus = new HttpPrometheus(this.metricsPort, 'near_bridge_eth2near_')
const clientBlockNumberGauge = httpPrometheus.gauge('client_block_number', 'current client block number')
const chainBlockNumberGauge = httpPrometheus.gauge('chain_block_number', 'current chain block number')
const errorsOnSubmitCounter = httpPrometheus.counter('errors_on_submit', 'number of errors while submitting header')
let previousBlockNumber
while (true) {
let clientBlockNumber
let chainBlockNumber
try {
// Even retry 10 times ethClientContract.last_block_number could still fail
// Return back to loop to avoid crash eth2near-relay.
clientBlockNumber = (
await this.ethClientContract.last_block_number()
).toNumber()
clientBlockNumberGauge.set(clientBlockNumber)
chainBlockNumber = await robustWeb3.getBlockNumber()
chainBlockNumberGauge.set(chainBlockNumber)
} catch (e) {
console.error(e)
continue
}
const predicate = async (value) => {
const blockNumber = clientBlockNumber - value
console.log('Checking block:', blockNumber)
try {
const chainBlock = await getEthBlock(blockNumber, robustWeb3)
/// Block is not ready
if (chainBlock === null) {
const seconds = 3
console.log(`Block ${blockNumber} is not ready. Sleeping ${seconds} seconds.`)
await sleep(seconds * 1000)
return await predicate(value)
}
const chainBlockHash = chainBlock.hash
const clientHashes = await this.ethClientContract.known_hashes(
blockNumber
)
if (clientHashes.find((x) => x === chainBlockHash)) {
return true
} else {
return false
}
} catch (e) {
console.error(e)
return await predicate(value)
}
}
const estimatedValued = (previousBlockNumber === undefined) ? 0 : clientBlockNumber - (previousBlockNumber + this.totalSubmitBlock)
/// In case there exist a fork, find how many steps should go backward (delta) to the first block
/// in the client that is also in the main chain. If the answer is 0, then the current head is valid
const delta = await binarySearchWithEstimate(0, clientBlockNumber, estimatedValued, predicate)
clientBlockNumber -= delta
previousBlockNumber = clientBlockNumber
if (clientBlockNumber < chainBlockNumber) {
try {
// Submit add_block txns
const blockPromises = []
let endBlock = Math.min(
clientBlockNumber + this.totalSubmitBlock,
chainBlockNumber
)
if (clientBlockNumber < 5) {
// Initially, do not add block concurrently
endBlock = clientBlockNumber + 1
}
for (let i = clientBlockNumber + 1; i <= endBlock; i++) {
blockPromises.push(this.getParseBlock(i))
}
const blocks = await Promise.all(blockPromises)
console.log(
`Got and parsed block ${clientBlockNumber + 1} to block ${endBlock}`
)
// Send all transactions in a single batch, so they are processed in order.
const actions = []
for (let i = clientBlockNumber + 1, j = 0; i <= endBlock; i++, j++) {
const action = this.submitBlock(blocks[j], i)
actions.push(action)
}
const task = this.ethClientContract.account.signAndSendTransaction({ receiverId: this.ethClientContract.contractId, actions })
console.log(
`Submit txn to add block ${clientBlockNumber + 1
} to block ${endBlock}`
)
await task
console.log(
`Success added block ${clientBlockNumber + 1} to block ${endBlock}. Chain block number: ${chainBlockNumber}`
)
} catch (e) {
errorsOnSubmitCounter.inc(1)
console.error(e)
}
} else {
await sleep(10000)
}
}
}
async getParseBlock (blockNumber) {
try {
const block = await getEthBlock(blockNumber, this.robustWeb3)
const blockRlp = this.web3.utils.bytesToHex(
web3BlockToRlp(block)
)
const unparsedBlock = await this.ethashproof.getParseBlock(blockNumber, blockRlp)
return JSON.parse(unparsedBlock)
} catch (e) {
console.error(`Failed to get or parse block ${blockNumber}: ${e}`)
}
}
submitBlock (block, blockNumber) {
const h512s = block.elements
.filter((_, index) => index % 2 === 0)
.map((element, index) => {
return (
this.web3.utils.padLeft(element, 64) +
this.web3.utils.padLeft(block.elements[index * 2 + 1], 64).substr(2)
)
})
let args = {
block_header: this.web3.utils.hexToBytes(block.header_rlp),
dag_nodes: h512s
.filter((_, index) => index % 2 === 0)
.map((element, index) => {
return {
dag_nodes: [element, h512s[index * 2 + 1]],
proof: block.merkle_proofs
.slice(
index * block.proof_length,
(index + 1) * block.proof_length
)
.map((leaf) => this.web3.utils.padLeft(leaf, 32))
}
})
}
args = serialize(borshSchema, 'addBlockHeaderInput', args)
return nearAPI.transactions.functionCall('add_block_header', args, this.gasPerTransaction)
}
}
exports.Eth2NearRelay = Eth2NearRelay
exports.EthProofExtractor = EthProofExtractor
exports.ethashproof = ethashproof
exports.EthOnNearClientContract = EthOnNearClientContract
exports.EthOnNearProverContract = EthOnNearProverContract
exports.logFromWeb3 = logFromWeb3
exports.receiptFromWeb3 = receiptFromWeb3
exports.ethToNearFindProof = ethToNearFindProof
exports.ethToNearFindStorageProof = ethToNearFindStorageProof
exports.dagMerkleRoots = dagMerkleRoots