feat: read slot from history (hybrid)

src/eth/storage/hybrid/hybrid_history.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use anyhow::Context;
 use sqlx::types::BigDecimal;
 use sqlx::FromRow;
 use sqlx::Pool;
@@ -170,19 +171,39 @@ impl HybridHistory {
         Ok(())
     }
 
-    pub async fn get_slot_at_point(&self, address: &Address, slot_index: &SlotIndex, point_in_time: &StoragePointInTime) -> Option<Slot> {
-        match point_in_time {
+    pub async fn get_slot_at_point(&self, address: &Address, slot_index: &SlotIndex, point_in_time: &StoragePointInTime) -> anyhow::Result<Option<Slot>> {
+        let slot = match point_in_time {
             StoragePointInTime::Present => self.hybrid_accounts_slots.get(address).map(|account_info| {
                 let value = account_info.slots.get(slot_index).map(|slot_info| slot_info.value.clone()).unwrap_or_default();
                 Slot {
                     index: slot_index.clone(),
                     value,
                 }
             }),
-            StoragePointInTime::Past(_number) => {
-                None //XXX TODO use postgres query
-            }
-        }
+            StoragePointInTime::Past(number) => sqlx::query_as!(
+                Slot,
+                r#"
+                    SELECT
+                    slot_index as "index: _",
+                    value as "value: _"
+                    FROM neo_account_slots
+                    WHERE account_address = $1
+                    AND slot_index = $2
+                    AND block_number = (SELECT MAX(block_number)
+                                            FROM historical_slots
+                                            WHERE account_address = $1
+                                            AND idx = $2
+                                            AND block_number <= $3)
+                "#,
+                address as _,
+                slot_index as _,
+                number as _
+            )
+            .fetch_optional(&*self.pool)
+            .await
+            .context("failed to select slot")?,
+        };
+        Ok(slot)
     }
 }
 

src/eth/storage/hybrid/mod.rs

@@ -255,9 +255,7 @@ impl PermanentStorage for HybridPermanentStorage {
 
     async fn maybe_read_slot(&self, address: &Address, slot_index: &SlotIndex, point_in_time: &StoragePointInTime) -> anyhow::Result<Option<Slot>> {
         tracing::debug!(%address, %slot_index, ?point_in_time, "reading slot");
-        let hybrid_state = self.hybrid_state.write().await;
-
-        Ok(hybrid_state.get_slot_at_point(address, slot_index, point_in_time).await)
+        self.hybrid_state.read().await.get_slot_at_point(address, slot_index, point_in_time).await
     }
 
     async fn read_block(&self, selection: &BlockSelection) -> anyhow::Result<Option<Block>> {

static/schema/001-init.sql

@@ -745,7 +745,7 @@ CREATE TABLE public.neo_account_slots (
     block_number BIGINT NOT NULL,
     slot_index BYTEA NOT NULL,
     account_address BYTEA NOT NULL,
-    value BYTEA,
+    value BYTEA NOT NULL,
     created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT now(),
     PRIMARY KEY (account_address, slot_index, block_number),
     FOREIGN KEY (block_number) REFERENCES public.neo_blocks(block_number)