),
140 | }
141 |
142 | /// Handles an internal provider and listens for requests.
143 | ///
144 | /// This handler will remain active as long as it is reachable (request channel still open) and
145 | /// requests are in progress.
146 | #[must_use = "futures do nothing unless polled"]
147 | pub struct BackendHandler {
148 | provider: P,
149 | /// Stores all the data.
150 | db: BlockchainDb,
151 | /// Requests currently in progress
152 | pending_requests: Vec>,
153 | /// Listeners that wait for a `get_account` related response
154 | account_requests: HashMap>,
155 | /// Listeners that wait for a `get_storage_at` response
156 | storage_requests: HashMap<(Address, U256), Vec>,
157 | /// Listeners that wait for a `get_block` response
158 | block_requests: HashMap>,
159 | /// Incoming commands.
160 | incoming: UnboundedReceiver,
161 | /// unprocessed queued requests
162 | queued_requests: VecDeque,
163 | /// The block to fetch data from.
164 | // This is an `Option` so that we can have less code churn in the functions below
165 | block_id: Option,
166 | }
167 |
168 | impl BackendHandler
169 | where
170 | P: Provider + Clone + Unpin + 'static,
171 | {
172 | fn new(
173 | provider: P,
174 | db: BlockchainDb,
175 | rx: UnboundedReceiver,
176 | block_id: Option,
177 | ) -> Self {
178 | Self {
179 | provider,
180 | db,
181 | pending_requests: Default::default(),
182 | account_requests: Default::default(),
183 | storage_requests: Default::default(),
184 | block_requests: Default::default(),
185 | queued_requests: Default::default(),
186 | incoming: rx,
187 | block_id,
188 | }
189 | }
190 |
191 | /// handle the request in queue in the future.
192 | ///
193 | /// We always check:
194 | /// 1. if the requested value is already stored in the cache, then answer the sender
195 | /// 2. otherwise, fetch it via the provider but check if a request for that value is already in
196 | /// progress (e.g. another Sender just requested the same account)
197 | fn on_request(&mut self, req: BackendRequest) {
198 | match req {
199 | BackendRequest::Basic(addr, sender) => {
200 | trace!(target: "backendhandler", "received request basic address={:?}", addr);
201 | let acc = self.db.accounts().read().get(&addr).cloned();
202 | if let Some(basic) = acc {
203 | let _ = sender.send(Ok(basic));
204 | } else {
205 | self.request_account(addr, sender);
206 | }
207 | }
208 | BackendRequest::BlockHash(number, sender) => {
209 | let hash = self.db.block_hashes().read().get(&U256::from(number)).cloned();
210 | if let Some(hash) = hash {
211 | let _ = sender.send(Ok(hash));
212 | } else {
213 | self.request_hash(number, sender);
214 | }
215 | }
216 | BackendRequest::FullBlock(number, sender) => {
217 | self.request_full_block(number, sender);
218 | }
219 | BackendRequest::Transaction(tx, sender) => {
220 | self.request_transaction(tx, sender);
221 | }
222 | BackendRequest::Storage(addr, idx, sender) => {
223 | // account is already stored in the cache
224 | let value =
225 | self.db.storage().read().get(&addr).and_then(|acc| acc.get(&idx).copied());
226 | if let Some(value) = value {
227 | let _ = sender.send(Ok(value));
228 | } else {
229 | // account present but not storage -> fetch storage
230 | self.request_account_storage(addr, idx, sender);
231 | }
232 | }
233 | BackendRequest::SetPinnedBlock(block_id) => {
234 | self.block_id = Some(block_id);
235 | }
236 | BackendRequest::UpdateAddress(address_data) => {
237 | for (address, data) in address_data {
238 | self.db.accounts().write().insert(address, data);
239 | }
240 | }
241 | BackendRequest::UpdateStorage(storage_data) => {
242 | for (address, data) in storage_data {
243 | self.db.storage().write().insert(address, data);
244 | }
245 | }
246 | BackendRequest::UpdateBlockHash(block_hash_data) => {
247 | for (block, hash) in block_hash_data {
248 | self.db.block_hashes().write().insert(block, hash);
249 | }
250 | }
251 | BackendRequest::AnyRequest(fut) => {
252 | self.pending_requests.push(ProviderRequest::AnyRequest(fut));
253 | }
254 | }
255 | }
256 |
257 | /// process a request for account's storage
258 | fn request_account_storage(&mut self, address: Address, idx: U256, listener: StorageSender) {
259 | match self.storage_requests.entry((address, idx)) {
260 | Entry::Occupied(mut entry) => {
261 | entry.get_mut().push(listener);
262 | }
263 | Entry::Vacant(entry) => {
264 | trace!(target: "backendhandler", %address, %idx, "preparing storage request");
265 | entry.insert(vec![listener]);
266 | let provider = self.provider.clone();
267 | let block_id = self.block_id.unwrap_or_default();
268 | let fut = Box::pin(async move {
269 | let storage = provider
270 | .get_storage_at(address, idx)
271 | .block_id(block_id)
272 | .await
273 | .map_err(Into::into);
274 | (storage, address, idx)
275 | });
276 | self.pending_requests.push(ProviderRequest::Storage(fut));
277 | }
278 | }
279 | }
280 |
281 | /// returns the future that fetches the account data
282 | fn get_account_req(&self, address: Address) -> ProviderRequest {
283 | trace!(target: "backendhandler", "preparing account request, address={:?}", address);
284 | let provider = self.provider.clone();
285 | let block_id = self.block_id.unwrap_or_default();
286 | let fut = Box::pin(async move {
287 | let balance = provider.get_balance(address).block_id(block_id).into_future();
288 | let nonce = provider.get_transaction_count(address).block_id(block_id).into_future();
289 | let code = provider.get_code_at(address).block_id(block_id).into_future();
290 | let resp = tokio::try_join!(balance, nonce, code).map_err(Into::into);
291 | (resp, address)
292 | });
293 | ProviderRequest::Account(fut)
294 | }
295 |
296 | /// process a request for an account
297 | fn request_account(&mut self, address: Address, listener: AccountInfoSender) {
298 | match self.account_requests.entry(address) {
299 | Entry::Occupied(mut entry) => {
300 | entry.get_mut().push(listener);
301 | }
302 | Entry::Vacant(entry) => {
303 | entry.insert(vec![listener]);
304 | self.pending_requests.push(self.get_account_req(address));
305 | }
306 | }
307 | }
308 |
309 | /// process a request for an entire block
310 | fn request_full_block(&mut self, number: BlockId, sender: FullBlockSender) {
311 | let provider = self.provider.clone();
312 | let fut = Box::pin(async move {
313 | let block = provider
314 | .get_block(number)
315 | .full()
316 | .await
317 | .wrap_err(format!("could not fetch block {number:?}"));
318 | (sender, block, number)
319 | });
320 |
321 | self.pending_requests.push(ProviderRequest::FullBlock(fut));
322 | }
323 |
324 | /// process a request for a transactions
325 | fn request_transaction(&mut self, tx: B256, sender: TransactionSender) {
326 | let provider = self.provider.clone();
327 | let fut = Box::pin(async move {
328 | let block = provider
329 | .get_transaction_by_hash(tx)
330 | .await
331 | .wrap_err_with(|| format!("could not get transaction {tx}"))
332 | .and_then(|maybe| {
333 | maybe.ok_or_else(|| eyre::eyre!("could not get transaction {tx}"))
334 | });
335 | (sender, block, tx)
336 | });
337 |
338 | self.pending_requests.push(ProviderRequest::Transaction(fut));
339 | }
340 |
341 | /// process a request for a block hash
342 | fn request_hash(&mut self, number: u64, listener: BlockHashSender) {
343 | match self.block_requests.entry(number) {
344 | Entry::Occupied(mut entry) => {
345 | entry.get_mut().push(listener);
346 | }
347 | Entry::Vacant(entry) => {
348 | trace!(target: "backendhandler", number, "preparing block hash request");
349 | entry.insert(vec![listener]);
350 | let provider = self.provider.clone();
351 | let fut = Box::pin(async move {
352 | let block = provider
353 | .get_block_by_number(number.into())
354 | .hashes()
355 | .await
356 | .wrap_err("failed to get block");
357 |
358 | let block_hash = match block {
359 | Ok(Some(block)) => Ok(block.header.hash),
360 | Ok(None) => {
361 | warn!(target: "backendhandler", ?number, "block not found");
362 | // if no block was returned then the block does not exist, in which case
363 | // we return empty hash
364 | Ok(KECCAK_EMPTY)
365 | }
366 | Err(err) => {
367 | error!(target: "backendhandler", %err, ?number, "failed to get block");
368 | Err(err)
369 | }
370 | };
371 | (block_hash, number)
372 | });
373 | self.pending_requests.push(ProviderRequest::BlockHash(fut));
374 | }
375 | }
376 | }
377 | }
378 |
379 | impl Future for BackendHandler
380 | where
381 | P: Provider + Clone + Unpin + 'static,
382 | {
383 | type Output = ();
384 |
385 | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll {
386 | let pin = self.get_mut();
387 | loop {
388 | // Drain queued requests first.
389 | while let Some(req) = pin.queued_requests.pop_front() {
390 | pin.on_request(req)
391 | }
392 |
393 | // receive new requests to delegate to the underlying provider
394 | loop {
395 | match Pin::new(&mut pin.incoming).poll_next(cx) {
396 | Poll::Ready(Some(req)) => {
397 | pin.queued_requests.push_back(req);
398 | }
399 | Poll::Ready(None) => {
400 | trace!(target: "backendhandler", "last sender dropped, ready to drop (&flush cache)");
401 | return Poll::Ready(());
402 | }
403 | Poll::Pending => break,
404 | }
405 | }
406 |
407 | // poll all requests in progress
408 | for n in (0..pin.pending_requests.len()).rev() {
409 | let mut request = pin.pending_requests.swap_remove(n);
410 | match &mut request {
411 | ProviderRequest::Account(fut) => {
412 | if let Poll::Ready((resp, addr)) = fut.poll_unpin(cx) {
413 | // get the response
414 | let (balance, nonce, code) = match resp {
415 | Ok(res) => res,
416 | Err(err) => {
417 | let err = Arc::new(err);
418 | if let Some(listeners) = pin.account_requests.remove(&addr) {
419 | listeners.into_iter().for_each(|l| {
420 | let _ = l.send(Err(DatabaseError::GetAccount(
421 | addr,
422 | Arc::clone(&err),
423 | )));
424 | })
425 | }
426 | continue;
427 | }
428 | };
429 |
430 | // convert it to revm-style types
431 | let (code, code_hash) = if !code.is_empty() {
432 | (code.clone(), keccak256(&code))
433 | } else {
434 | (Bytes::default(), KECCAK_EMPTY)
435 | };
436 |
437 | // update the cache
438 | let acc = AccountInfo {
439 | nonce,
440 | balance,
441 | code: Some(Bytecode::new_raw(code)),
442 | code_hash,
443 | };
444 | pin.db.accounts().write().insert(addr, acc.clone());
445 |
446 | // notify all listeners
447 | if let Some(listeners) = pin.account_requests.remove(&addr) {
448 | listeners.into_iter().for_each(|l| {
449 | let _ = l.send(Ok(acc.clone()));
450 | })
451 | }
452 | continue;
453 | }
454 | }
455 | ProviderRequest::Storage(fut) => {
456 | if let Poll::Ready((resp, addr, idx)) = fut.poll_unpin(cx) {
457 | let value = match resp {
458 | Ok(value) => value,
459 | Err(err) => {
460 | // notify all listeners
461 | let err = Arc::new(err);
462 | if let Some(listeners) =
463 | pin.storage_requests.remove(&(addr, idx))
464 | {
465 | listeners.into_iter().for_each(|l| {
466 | let _ = l.send(Err(DatabaseError::GetStorage(
467 | addr,
468 | idx,
469 | Arc::clone(&err),
470 | )));
471 | })
472 | }
473 | continue;
474 | }
475 | };
476 |
477 | // update the cache
478 | pin.db.storage().write().entry(addr).or_default().insert(idx, value);
479 |
480 | // notify all listeners
481 | if let Some(listeners) = pin.storage_requests.remove(&(addr, idx)) {
482 | listeners.into_iter().for_each(|l| {
483 | let _ = l.send(Ok(value));
484 | })
485 | }
486 | continue;
487 | }
488 | }
489 | ProviderRequest::BlockHash(fut) => {
490 | if let Poll::Ready((block_hash, number)) = fut.poll_unpin(cx) {
491 | let value = match block_hash {
492 | Ok(value) => value,
493 | Err(err) => {
494 | let err = Arc::new(err);
495 | // notify all listeners
496 | if let Some(listeners) = pin.block_requests.remove(&number) {
497 | listeners.into_iter().for_each(|l| {
498 | let _ = l.send(Err(DatabaseError::GetBlockHash(
499 | number,
500 | Arc::clone(&err),
501 | )));
502 | })
503 | }
504 | continue;
505 | }
506 | };
507 |
508 | // update the cache
509 | pin.db.block_hashes().write().insert(U256::from(number), value);
510 |
511 | // notify all listeners
512 | if let Some(listeners) = pin.block_requests.remove(&number) {
513 | listeners.into_iter().for_each(|l| {
514 | let _ = l.send(Ok(value));
515 | })
516 | }
517 | continue;
518 | }
519 | }
520 | ProviderRequest::FullBlock(fut) => {
521 | if let Poll::Ready((sender, resp, number)) = fut.poll_unpin(cx) {
522 | let msg = match resp {
523 | Ok(Some(block)) => Ok(block),
524 | Ok(None) => Err(DatabaseError::BlockNotFound(number)),
525 | Err(err) => {
526 | let err = Arc::new(err);
527 | Err(DatabaseError::GetFullBlock(number, err))
528 | }
529 | };
530 | let _ = sender.send(msg);
531 | continue;
532 | }
533 | }
534 | ProviderRequest::Transaction(fut) => {
535 | if let Poll::Ready((sender, tx, tx_hash)) = fut.poll_unpin(cx) {
536 | let msg = match tx {
537 | Ok(tx) => Ok(tx),
538 | Err(err) => {
539 | let err = Arc::new(err);
540 | Err(DatabaseError::GetTransaction(tx_hash, err))
541 | }
542 | };
543 | let _ = sender.send(msg);
544 | continue;
545 | }
546 | }
547 | ProviderRequest::AnyRequest(fut) => {
548 | if fut.poll_inner(cx).is_ready() {
549 | continue;
550 | }
551 | }
552 | }
553 | // not ready, insert and poll again
554 | pin.pending_requests.push(request);
555 | }
556 |
557 | // If no new requests have been queued, break to
558 | // be polled again later.
559 | if pin.queued_requests.is_empty() {
560 | return Poll::Pending;
561 | }
562 | }
563 | }
564 | }
565 |
566 | /// Mode for the `SharedBackend` how to block in the non-async [`DatabaseRef`] when interacting with
567 | /// [`BackendHandler`].
568 | #[derive(Default, Clone, Debug, PartialEq)]
569 | pub enum BlockingMode {
570 | /// This mode use `tokio::task::block_in_place()` to block in place.
571 | ///
572 | /// This should be used when blocking on the call site is disallowed.
573 | #[default]
574 | BlockInPlace,
575 | /// The mode blocks the current task
576 | ///
577 | /// This can be used if blocking on the call site is allowed, e.g. on a tokio blocking task.
578 | Block,
579 | }
580 |
581 | impl BlockingMode {
582 | /// run process logic with the blocking mode
583 | pub fn run(&self, f: F) -> R
584 | where
585 | F: FnOnce() -> R,
586 | {
587 | match self {
588 | Self::BlockInPlace => tokio::task::block_in_place(f),
589 | Self::Block => f(),
590 | }
591 | }
592 | }
593 |
594 | /// A cloneable backend type that shares access to the backend data with all its clones.
595 | ///
596 | /// This backend type is connected to the `BackendHandler` via a mpsc unbounded channel. The
597 | /// `BackendHandler` is spawned on a tokio task and listens for incoming commands on the receiver
598 | /// half of the channel. A `SharedBackend` holds a sender for that channel, which is `Clone`, so
599 | /// there can be multiple `SharedBackend`s communicating with the same `BackendHandler`, hence this
600 | /// `Backend` type is thread safe.
601 | ///
602 | /// All `Backend` trait functions are delegated as a `BackendRequest` via the channel to the
603 | /// `BackendHandler`. All `BackendRequest` variants include a sender half of an additional channel
604 | /// that is used by the `BackendHandler` to send the result of an executed `BackendRequest` back to
605 | /// `SharedBackend`.
606 | ///
607 | /// The `BackendHandler` holds a `Provider` to look up missing accounts or storage slots
608 | /// from remote (e.g. infura). It detects duplicate requests from multiple `SharedBackend`s and
609 | /// bundles them together, so that always only one provider request is executed. For example, there
610 | /// are two `SharedBackend`s, `A` and `B`, both request the basic account info of account
611 | /// `0xasd9sa7d...` at the same time. After the `BackendHandler` receives the request from `A`, it
612 | /// sends a new provider request to the provider's endpoint, then it reads the identical request
613 | /// from `B` and simply adds it as an additional listener for the request already in progress,
614 | /// instead of sending another one. So that after the provider returns the response all listeners
615 | /// (`A` and `B`) get notified.
616 | // **Note**: the implementation makes use of [tokio::task::block_in_place()] when interacting with
617 | // the underlying [BackendHandler] which runs on a separate spawned tokio task.
618 | // [tokio::task::block_in_place()]
619 | // > Runs the provided blocking function on the current thread without blocking the executor.
620 | // This prevents issues (hangs) we ran into were the [SharedBackend] itself is called from a spawned
621 | // task.
622 | #[derive(Clone, Debug)]
623 | pub struct SharedBackend {
624 | /// channel used for sending commands related to database operations
625 | backend: UnboundedSender,
626 | /// Ensures that the underlying cache gets flushed once the last `SharedBackend` is dropped.
627 | ///
628 | /// There is only one instance of the type, so as soon as the last `SharedBackend` is deleted,
629 | /// `FlushJsonBlockCacheDB` is also deleted and the cache is flushed.
630 | cache: Arc,
631 |
632 | /// The mode for the `SharedBackend` to block in place or not
633 | blocking_mode: BlockingMode,
634 | }
635 |
636 | impl SharedBackend {
637 | /// _Spawns_ a new `BackendHandler` on a `tokio::task` that listens for requests from any
638 | /// `SharedBackend`. Missing values get inserted in the `db`.
639 | ///
640 | /// The spawned `BackendHandler` finishes once the last `SharedBackend` connected to it is
641 | /// dropped.
642 | ///
643 | /// NOTE: this should be called with `Arc`
644 | pub async fn spawn_backend(provider: P, db: BlockchainDb, pin_block: Option) -> Self
645 | where
646 | P: Provider + Unpin + 'static + Clone,
647 | {
648 | let (shared, handler) = Self::new(provider, db, pin_block);
649 | // spawn the provider handler to a task
650 | trace!(target: "backendhandler", "spawning Backendhandler task");
651 | tokio::spawn(handler);
652 | shared
653 | }
654 |
655 | /// Same as `Self::spawn_backend` but spawns the `BackendHandler` on a separate `std::thread` in
656 | /// its own `tokio::Runtime`
657 | pub fn spawn_backend_thread(
658 | provider: P,
659 | db: BlockchainDb,
660 | pin_block: Option,
661 | ) -> Self
662 | where
663 | P: Provider + Unpin + 'static + Clone,
664 | {
665 | let (shared, handler) = Self::new(provider, db, pin_block);
666 |
667 | // spawn a light-weight thread with a thread-local async runtime just for
668 | // sending and receiving data from the remote client
669 | std::thread::Builder::new()
670 | .name("fork-backend".into())
671 | .spawn(move || {
672 | let rt = tokio::runtime::Builder::new_current_thread()
673 | .enable_all()
674 | .build()
675 | .expect("failed to build tokio runtime");
676 |
677 | rt.block_on(handler);
678 | })
679 | .expect("failed to spawn thread");
680 | trace!(target: "backendhandler", "spawned Backendhandler thread");
681 |
682 | shared
683 | }
684 |
685 | /// Returns a new `SharedBackend` and the `BackendHandler`
686 | pub fn new(
687 | provider: P,
688 | db: BlockchainDb,
689 | pin_block: Option,
690 | ) -> (Self, BackendHandler)
691 | where
692 | P: Provider + Unpin + 'static + Clone,
693 | {
694 | let (backend, backend_rx) = unbounded();
695 | let cache = Arc::new(FlushJsonBlockCacheDB(Arc::clone(db.cache())));
696 | let handler = BackendHandler::new(provider, db, backend_rx, pin_block);
697 | (Self { backend, cache, blocking_mode: Default::default() }, handler)
698 | }
699 |
700 | /// Returns a new `SharedBackend` and the `BackendHandler` with a specific blocking mode
701 | pub fn with_blocking_mode(&self, mode: BlockingMode) -> Self {
702 | Self { backend: self.backend.clone(), cache: self.cache.clone(), blocking_mode: mode }
703 | }
704 |
705 | /// Updates the pinned block to fetch data from
706 | pub fn set_pinned_block(&self, block: impl Into) -> eyre::Result<()> {
707 | let req = BackendRequest::SetPinnedBlock(block.into());
708 | self.backend.unbounded_send(req).map_err(|e| eyre::eyre!("{:?}", e))
709 | }
710 |
711 | /// Returns the full block for the given block identifier
712 | pub fn get_full_block(&self, block: impl Into) -> DatabaseResult {
713 | self.blocking_mode.run(|| {
714 | let (sender, rx) = oneshot_channel();
715 | let req = BackendRequest::FullBlock(block.into(), sender);
716 | self.backend.unbounded_send(req)?;
717 | rx.recv()?
718 | })
719 | }
720 |
721 | /// Returns the transaction for the hash
722 | pub fn get_transaction(&self, tx: B256) -> DatabaseResult {
723 | self.blocking_mode.run(|| {
724 | let (sender, rx) = oneshot_channel();
725 | let req = BackendRequest::Transaction(tx, sender);
726 | self.backend.unbounded_send(req)?;
727 | rx.recv()?
728 | })
729 | }
730 |
731 | fn do_get_basic(&self, address: Address) -> DatabaseResult> {
732 | self.blocking_mode.run(|| {
733 | let (sender, rx) = oneshot_channel();
734 | let req = BackendRequest::Basic(address, sender);
735 | self.backend.unbounded_send(req)?;
736 | rx.recv()?.map(Some)
737 | })
738 | }
739 |
740 | fn do_get_storage(&self, address: Address, index: U256) -> DatabaseResult {
741 | self.blocking_mode.run(|| {
742 | let (sender, rx) = oneshot_channel();
743 | let req = BackendRequest::Storage(address, index, sender);
744 | self.backend.unbounded_send(req)?;
745 | rx.recv()?
746 | })
747 | }
748 |
749 | fn do_get_block_hash(&self, number: u64) -> DatabaseResult {
750 | self.blocking_mode.run(|| {
751 | let (sender, rx) = oneshot_channel();
752 | let req = BackendRequest::BlockHash(number, sender);
753 | self.backend.unbounded_send(req)?;
754 | rx.recv()?
755 | })
756 | }
757 |
758 | /// Inserts or updates data for multiple addresses
759 | pub fn insert_or_update_address(&self, address_data: AddressData) {
760 | let req = BackendRequest::UpdateAddress(address_data);
761 | let err = self.backend.unbounded_send(req);
762 | match err {
763 | Ok(_) => (),
764 | Err(e) => {
765 | error!(target: "sharedbackend", "Failed to send update address request: {:?}", e)
766 | }
767 | }
768 | }
769 |
770 | /// Inserts or updates data for multiple storage slots
771 | pub fn insert_or_update_storage(&self, storage_data: StorageData) {
772 | let req = BackendRequest::UpdateStorage(storage_data);
773 | let err = self.backend.unbounded_send(req);
774 | match err {
775 | Ok(_) => (),
776 | Err(e) => {
777 | error!(target: "sharedbackend", "Failed to send update address request: {:?}", e)
778 | }
779 | }
780 | }
781 |
782 | /// Inserts or updates data for multiple block hashes
783 | pub fn insert_or_update_block_hashes(&self, block_hash_data: BlockHashData) {
784 | let req = BackendRequest::UpdateBlockHash(block_hash_data);
785 | let err = self.backend.unbounded_send(req);
786 | match err {
787 | Ok(_) => (),
788 | Err(e) => {
789 | error!(target: "sharedbackend", "Failed to send update address request: {:?}", e)
790 | }
791 | }
792 | }
793 |
794 | /// Returns any arbitrary request on the provider
795 | pub fn do_any_request(&mut self, fut: F) -> DatabaseResult
796 | where
797 | F: Future