Implement Async Script Verification RFC

.gitignore

@@ -9,3 +9,4 @@
 # Vscode detrius
 .vscode/
 .zebra-state/
+.cargo/

zebra-chain/src/transaction/hash.rs

@@ -13,7 +13,7 @@ use super::Transaction;
 ///
 /// TODO: I'm pretty sure this is also a SHA256d hash but I haven't
 /// confirmed it yet.
-#[derive(Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Copy, Clone, Eq, PartialEq, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(Arbitrary))]
 pub struct Hash(pub [u8; 32]);
 

zebra-chain/src/transparent.rs

@@ -40,7 +40,7 @@ impl AsRef<[u8]> for CoinbaseData {
 /// OutPoint
 ///
 /// A particular transaction output reference.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(Arbitrary))]
 pub struct OutPoint {
     /// References the transaction that contains the UTXO being spent.

zebra-state/Cargo.toml

@@ -22,6 +22,7 @@ tower = "0.3.1"
 tracing = "0.1"
 tracing-error = "0.1.2"
 thiserror = "1.0.20"
+tokio = "0.2.22"
 
 [dev-dependencies]
 zebra-test = { path = "../zebra-test/" }

zebra-state/src/in_memory.rs

@@ -105,6 +105,7 @@ impl Service<Request> for InMemoryState {
 
                 async move { Ok(Response::BlockLocator { block_locator }) }.boxed()
             }
+            Request::AwaitUtxo(_) => unimplemented!("this Service is being removed"),
         }
     }
 }

zebra-state/src/lib.rs

@@ -24,6 +24,7 @@ use tower::{Service, ServiceExt};
 use zebra_chain::{
     block::{self, Block},
     parameters::Network,
+    transparent,
 };
 
 pub mod in_memory;
@@ -126,6 +127,11 @@ pub enum Request {
         /// The hash to check against the current chain
         hash: block::Hash,
     },
+    /// Request a UTXO identified by the given Outpoint
+    AwaitUtxo(
+        /// The outpoint identifying with the requested UTXO
+        transparent::OutPoint,
+    ),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -158,6 +164,11 @@ pub enum Response {
         /// The number of blocks above the given block in the current best chain
         Option<u32>,
     ),
+    /// The response to a `AwaitUtxo` request
+    Utxo(
+        /// The transparent::Output representing the requested UTXO
+        transparent::Output,
+    ),
 }
 
 /// Get the heights of the blocks for constructing a block_locator list

zebra-state/src/on_disk.rs

@@ -17,6 +17,8 @@ use zebra_chain::{
     parameters::Network,
 };
 
+mod utxo;
+
 /// Type alias of our wrapped service
 pub type StateService = Buffer<BoxService<Request, Response, Error>, Request>;
 
@@ -211,6 +213,7 @@ impl Service<Request> for SledState {
                 }
                 .boxed()
             }
+            Request::AwaitUtxo(_) => todo!("blocked waiting for chain state RFC implementation"),
         }
     }
 }

zebra-state/src/on_disk/utxo.rs

@@ -0,0 +1,44 @@
+#![allow(dead_code)]
+use crate::{Error, Response};
+use std::collections::HashMap;
+use std::future::Future;
+use tokio::sync::broadcast;
+use zebra_chain::transparent;
+
+pub(super) struct PendingUtxos(
+    HashMap<transparent::OutPoint, broadcast::Sender<transparent::Output>>,
+);
+
+impl PendingUtxos {
+    pub(super) fn queue(
+        &mut self,
+        outpoint: transparent::OutPoint,
+    ) -> impl Future<Output = Result<Response, Error>> {
+        let mut receiver = self
+            .0
+            .entry(outpoint)
+            .or_insert_with(|| {
+                let (sender, _) = broadcast::channel(1);
+                sender
+            })
+            .subscribe();
+
+        async move {
+            receiver
+                .recv()
+                .await
+                .map(Response::Utxo)
+                .map_err(Error::from)
+        }
+    }
+
+    pub(super) fn respond(&mut self, outpoint: transparent::OutPoint, output: transparent::Output) {
+        if let Some(sender) = self.0.remove(&outpoint) {
+            let _ = sender.send(output);
+        }
+    }
+
+    pub(super) fn prune(&mut self) {
+        self.0.retain(|_, chan| chan.receiver_count() > 0);
+    }
+}