Merge BlockstreamResearch#265: Remove WitnessNode

61b7ddc refactor: Remove WitnessNode (Christian Lewe)
3be0fd9 refactor: Remove Error::NoMoreWitnesses (Christian Lewe)

Pull request description:

  Remove `WitnessNode` by merging its code with the nearly identical `ConstructNode`.

ACKs for top commit:
  apoelstra:
    ACK 61b7ddc; successfully ran local tests

Tree-SHA512: 1ab95ad4b73552cfa9285f7aeba10faa2c4936f708f722667c3c44f3ce1463351ca23319129fe0aa6640004ce665bb23fc6faa754c1c9ea81b71e83d06f62bb0

Author: apoelstra

src/bit_encoding/decode.rs

@@ -9,7 +9,7 @@ use crate::dag::{Dag, DagLike, InternalSharing};
 use crate::jet::Jet;
 use crate::merkle::cmr::Cmr;
 use crate::node::{
-    ConstructNode, CoreConstructible, DisconnectConstructible, JetConstructible, NoWitness,
+    ConstructNode, CoreConstructible, DisconnectConstructible, JetConstructible,
     WitnessConstructible,
 };
 use crate::types;
@@ -235,7 +235,7 @@ pub fn decode_expression<I: Iterator<Item = u8>, J: Jet>(
                 converted[i].get()?,
                 &Some(Arc::clone(converted[j].get()?)),
             )?),
-            DecodeNode::Witness => Node(ArcNode::witness(&inference_context, NoWitness)),
+            DecodeNode::Witness => Node(ArcNode::witness(&inference_context, None)),
             DecodeNode::Fail(entropy) => Node(ArcNode::fail(&inference_context, entropy)),
             DecodeNode::Hidden(cmr) => {
                 if !hidden_set.insert(cmr) {

src/human_encoding/mod.rs

@@ -13,7 +13,7 @@ mod parse;
 use crate::dag::{DagLike, MaxSharing};
 use crate::jet::Jet;
 use crate::node::{self, CommitNode, NoWitness};
-use crate::{Cmr, Imr, Value, WitnessNode};
+use crate::{Cmr, ConstructNode, Imr, Value};
 
 use std::collections::HashMap;
 use std::str;
@@ -213,9 +213,9 @@ impl<J: Jet> Forest<J> {
     pub fn to_witness_node(
         &self,
         witness: &HashMap<Arc<str>, Value>,
-    ) -> Option<Arc<WitnessNode<J>>> {
+    ) -> Option<Arc<ConstructNode<J>>> {
         let main = self.roots.get("main")?;
-        Some(main.to_witness_node(witness, self.roots()))
+        Some(main.to_construct_node(witness, self.roots()))
     }
 }
 

src/human_encoding/named_node.rs

@@ -6,13 +6,12 @@ use crate::dag::{InternalSharing, MaxSharing, PostOrderIterItem};
 use crate::human_encoding::{Error, ErrorSet, Position, WitnessOrHole};
 use crate::jet::Jet;
 use crate::node::{
-    self, Commit, CommitData, CommitNode, Converter, Inner, NoDisconnect, NoWitness, Node, Witness,
-    WitnessData,
+    self, Commit, CommitData, CommitNode, Construct, ConstructData, Constructible as _, Converter,
+    CoreConstructible as _, Inner, NoDisconnect, NoWitness, Node,
 };
-use crate::node::{Construct, ConstructData, Constructible as _, CoreConstructible as _};
 use crate::types;
 use crate::types::arrow::{Arrow, FinalArrow};
-use crate::{encode, Value, WitnessNode};
+use crate::{encode, ConstructNode, Value};
 use crate::{BitWriter, Cmr, Imr};
 
 use std::collections::HashMap;
@@ -108,19 +107,19 @@ impl<J: Jet> NamedCommitNode<J> {
             .unwrap()
     }
 
-    pub fn to_witness_node(
+    pub fn to_construct_node(
         &self,
         witness: &HashMap<Arc<str>, Value>,
         disconnect: &HashMap<Arc<str>, Arc<NamedCommitNode<J>>>,
-    ) -> Arc<WitnessNode<J>> {
+    ) -> Arc<ConstructNode<J>> {
         struct Populator<'a, J: Jet> {
             witness_map: &'a HashMap<Arc<str>, Value>,
             disconnect_map: &'a HashMap<Arc<str>, Arc<NamedCommitNode<J>>>,
             inference_context: types::Context,
             phantom: PhantomData<J>,
         }
 
-        impl<J: Jet> Converter<Named<Commit<J>>, Witness<J>> for Populator<'_, J> {
+        impl<J: Jet> Converter<Named<Commit<J>>, Construct<J>> for Populator<'_, J> {
             type Error = ();
 
             fn convert_witness(
@@ -140,9 +139,9 @@ impl<J: Jet> NamedCommitNode<J> {
             fn convert_disconnect(
                 &mut self,
                 data: &PostOrderIterItem<&Node<Named<Commit<J>>>>,
-                maybe_converted: Option<&Arc<Node<Witness<J>>>>,
+                maybe_converted: Option<&Arc<Node<Construct<J>>>>,
                 _: &Arc<str>,
-            ) -> Result<Option<Arc<Node<Witness<J>>>>, Self::Error> {
+            ) -> Result<Option<Arc<Node<Construct<J>>>>, Self::Error> {
                 if let Some(converted) = maybe_converted {
                     Ok(Some(converted.clone()))
                 } else {
@@ -172,16 +171,16 @@ impl<J: Jet> NamedCommitNode<J> {
                 &mut self,
                 _: &PostOrderIterItem<&Node<Named<Commit<J>>>>,
                 inner: Inner<
-                    &Arc<Node<Witness<J>>>,
+                    &Arc<Node<Construct<J>>>,
                     J,
-                    &Option<Arc<WitnessNode<J>>>,
+                    &Option<Arc<ConstructNode<J>>>,
                     &Option<Value>,
                 >,
-            ) -> Result<WitnessData<J>, Self::Error> {
+            ) -> Result<ConstructData<J>, Self::Error> {
                 let inner = inner
                     .map(|node| node.cached_data())
                     .map_witness(|maybe_value| maybe_value.clone());
-                Ok(WitnessData::from_inner(&self.inference_context, inner)
+                Ok(ConstructData::from_inner(&self.inference_context, inner)
                     .expect("types are already finalized"))
             }
         }
@@ -260,7 +259,7 @@ impl<J: Jet> NamedConstructNode<J> {
                 .as_ref()
                 .map(|data| &data.cached_data().internal)
                 .map_disconnect(|_| &None)
-                .map_witness(|_| NoWitness),
+                .map_witness(|_| None),
         )?;
         let named_data = NamedConstructData {
             internal: construct_data,

src/human_encoding/parse/mod.rs

@@ -591,7 +591,7 @@ mod tests {
                 assert_eq!(main.cmr().to_string(), cmr);
 
                 let program = main
-                    .to_witness_node(witness, &forest)
+                    .to_construct_node(witness, &forest)
                     .finalize_unpruned()
                     .expect("finalize");
 

src/lib.rs

@@ -65,7 +65,7 @@ pub use crate::merkle::{
     tmr::Tmr,
     FailEntropy, HasCmr,
 };
-pub use crate::node::{CommitNode, ConstructNode, Hiding, RedeemNode, WitnessNode};
+pub use crate::node::{CommitNode, ConstructNode, Hiding, RedeemNode};
 pub use crate::value::{Value, Word};
 pub use simplicity_sys as ffi;
 use std::fmt;
@@ -88,8 +88,6 @@ pub enum Error {
     Type(types::Error),
     // Execution error
     Execution(bit_machine::ExecutionError),
-    /// Witness iterator ended early
-    NoMoreWitnesses,
     /// Tried to parse a jet but the name wasn't recognized
     InvalidJetName(String),
     /// Policy error
@@ -107,7 +105,6 @@ impl fmt::Display for Error {
             Error::Type(ref e) => fmt::Display::fmt(e, f),
             Error::Execution(ref e) => fmt::Display::fmt(e, f),
             Error::InvalidJetName(s) => write!(f, "unknown jet `{}`", s),
-            Error::NoMoreWitnesses => f.write_str("no more witness data available"),
             #[cfg(feature = "elements")]
             Error::Policy(ref e) => fmt::Display::fmt(e, f),
         }
@@ -121,7 +118,6 @@ impl std::error::Error for Error {
             Error::DisconnectRedeemTime => None,
             Error::Type(ref e) => Some(e),
             Error::Execution(ref e) => Some(e),
-            Error::NoMoreWitnesses => None,
             Error::InvalidJetName(..) => None,
             #[cfg(feature = "elements")]
             Error::Policy(ref e) => Some(e),

src/node/commit.rs

@@ -3,7 +3,7 @@
 use crate::dag::{DagLike, MaxSharing, NoSharing, PostOrderIterItem};
 use crate::jet::Jet;
 use crate::types::arrow::{Arrow, FinalArrow};
-use crate::{encode, types};
+use crate::{encode, types, Value};
 use crate::{Amr, BitIter, BitWriter, Cmr, Error, FirstPassImr, Imr};
 
 use super::{
@@ -213,8 +213,8 @@ impl<J: Jet> CommitNode<J> {
                 &mut self,
                 _: &PostOrderIterItem<&CommitNode<J>>,
                 _: &NoWitness,
-            ) -> Result<NoWitness, Self::Error> {
-                Ok(NoWitness)
+            ) -> Result<Option<Value>, Self::Error> {
+                Ok(None)
             }
 
             fn convert_disconnect(
@@ -229,7 +229,12 @@ impl<J: Jet> CommitNode<J> {
             fn convert_data(
                 &mut self,
                 _: &PostOrderIterItem<&CommitNode<J>>,
-                inner: Inner<&Arc<ConstructNode<J>>, J, &Option<Arc<ConstructNode<J>>>, &NoWitness>,
+                inner: Inner<
+                    &Arc<ConstructNode<J>>,
+                    J,
+                    &Option<Arc<ConstructNode<J>>>,
+                    &Option<Value>,
+                >,
             ) -> Result<ConstructData<J>, Self::Error> {
                 let inner = inner
                     .map(|node| node.arrow())

src/node/construct.rs

@@ -1,18 +1,17 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use crate::dag::{InternalSharing, PostOrderIterItem};
-use crate::encode;
 use crate::jet::Jet;
 use crate::types::{self, arrow::Arrow};
-use crate::{BitIter, BitWriter, Cmr, FailEntropy};
+use crate::{encode, BitIter, BitWriter, Cmr, FailEntropy, RedeemNode, Value, Word};
 
-use crate::value::Word;
 use std::io;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
 use super::{
     Commit, CommitData, CommitNode, Converter, Inner, Marker, NoDisconnect, NoWitness, Node,
+    Redeem, RedeemData,
 };
 use super::{CoreConstructible, DisconnectConstructible, JetConstructible, WitnessConstructible};
 
@@ -33,7 +32,7 @@ pub struct Construct<J> {
 
 impl<J: Jet> Marker for Construct<J> {
     type CachedData = ConstructData<J>;
-    type Witness = NoWitness;
+    type Witness = Option<Value>;
     type Disconnect = Option<Arc<ConstructNode<J>>>;
     type SharingId = ConstructId;
     type Jet = J;
@@ -90,7 +89,7 @@ impl<J: Jet> ConstructNode<J> {
             fn convert_witness(
                 &mut self,
                 _: &PostOrderIterItem<&ConstructNode<J>>,
-                _: &NoWitness,
+                _: &Option<Value>,
             ) -> Result<NoWitness, Self::Error> {
                 Ok(NoWitness)
             }
@@ -119,6 +118,104 @@ impl<J: Jet> ConstructNode<J> {
         self.convert::<InternalSharing, _, _>(&mut FinalizeTypes(PhantomData))
     }
 
+    /// Finalize the witness program as an unpruned redeem program.
+    ///
+    /// Witness nodes must be populated with sufficient data,
+    /// to ensure that the resulting redeem program successfully runs on the Bit Machine.
+    /// Furthermore, **all** disconnected branches must be populated,
+    /// even those that are not executed.
+    ///
+    /// The resulting redeem program is **not pruned**.
+    ///
+    /// ## See
+    ///
+    /// [`RedeemNode::prune`]
+    pub fn finalize_unpruned(&self) -> Result<Arc<RedeemNode<J>>, crate::Error> {
+        struct Finalizer<J>(PhantomData<J>);
+
+        impl<J: Jet> Converter<Construct<J>, Redeem<J>> for Finalizer<J> {
+            type Error = crate::Error;
+
+            fn convert_witness(
+                &mut self,
+                data: &PostOrderIterItem<&ConstructNode<J>>,
+                wit: &Option<Value>,
+            ) -> Result<Value, Self::Error> {
+                if let Some(ref wit) = wit {
+                    Ok(wit.shallow_clone())
+                } else {
+                    // We insert a zero value into unpopulated witness nodes,
+                    // assuming that this node will later be pruned out of the program.
+                    //
+                    // Pruning requires running a program on the Bit Machine,
+                    // which in turn requires a program with fully populated witness nodes.
+                    // It would be horrible UX to force the caller to provide witness data
+                    // even for unexecuted branches, so we insert zero values here.
+                    //
+                    // If this node is executed after all, then the caller can fix the witness
+                    // data based on the returned execution error.
+                    //
+                    // Zero values may "accidentally" satisfy a program even if the caller
+                    // didn't provide any witness data. However, this is only the case for the
+                    // most trivial programs. The only place where we must be careful is our
+                    // unit tests, which tend to include these kinds of trivial programs.
+                    let ty = data.node.arrow().target.finalize()?;
+                    Ok(Value::zero(&ty))
+                }
+            }
+
+            fn convert_disconnect(
+                &mut self,
+                _: &PostOrderIterItem<&ConstructNode<J>>,
+                maybe_converted: Option<&Arc<RedeemNode<J>>>,
+                _: &Option<Arc<ConstructNode<J>>>,
+            ) -> Result<Arc<RedeemNode<J>>, Self::Error> {
+                if let Some(child) = maybe_converted {
+                    Ok(Arc::clone(child))
+                } else {
+                    Err(crate::Error::DisconnectRedeemTime)
+                }
+            }
+
+            fn convert_data(
+                &mut self,
+                data: &PostOrderIterItem<&ConstructNode<J>>,
+                inner: Inner<&Arc<RedeemNode<J>>, J, &Arc<RedeemNode<J>>, &Value>,
+            ) -> Result<Arc<RedeemData<J>>, Self::Error> {
+                let converted_data = inner
+                    .map(|node| node.cached_data())
+                    .map_disconnect(|node| node.cached_data())
+                    .map_witness(Value::shallow_clone);
+                Ok(Arc::new(RedeemData::new(
+                    data.node.arrow().finalize()?,
+                    converted_data,
+                )))
+            }
+        }
+
+        self.convert::<InternalSharing, _, _>(&mut Finalizer(PhantomData))
+    }
+
+    /// Finalize the witness program as a pruned redeem program.
+    ///
+    /// Witness nodes must be populated with sufficient data,
+    /// to ensure that the resulting redeem program successfully runs on the Bit Machine.
+    /// Furthermore, **all** disconnected branches must be populated,
+    /// even those that are not executed.
+    ///
+    /// The resulting redeem program is **pruned** based on the given transaction environment.
+    ///
+    /// ## See
+    ///
+    /// [`RedeemNode::prune`]
+    pub fn finalize_pruned(
+        &self,
+        env: &J::Environment,
+    ) -> Result<Arc<RedeemNode<J>>, crate::Error> {
+        let unpruned = self.finalize_unpruned()?;
+        unpruned.prune(env).map_err(crate::Error::Execution)
+    }
+
     /// Decode a Simplicity expression from bits, without witness data.
     ///
     /// # Usage
@@ -278,10 +375,10 @@ impl<J: Jet> DisconnectConstructible<Option<Arc<ConstructNode<J>>>> for Construc
     }
 }
 
-impl<J> WitnessConstructible<NoWitness> for ConstructData<J> {
-    fn witness(inference_context: &types::Context, witness: NoWitness) -> Self {
+impl<J> WitnessConstructible<Option<Value>> for ConstructData<J> {
+    fn witness(inference_context: &types::Context, _witness: Option<Value>) -> Self {
         ConstructData {
-            arrow: Arrow::witness(inference_context, witness),
+            arrow: Arrow::witness(inference_context, NoWitness),
             phantom: PhantomData,
         }
     }
@@ -340,7 +437,7 @@ mod tests {
     fn occurs_check_3() {
         let ctx = types::Context::new();
         // A similar example that caused a slightly different deadlock in the past.
-        let wit = Arc::<ConstructNode<Core>>::witness(&ctx, NoWitness);
+        let wit = Arc::<ConstructNode<Core>>::witness(&ctx, None);
         let drop = Arc::<ConstructNode<Core>>::drop_(&wit);
 
         let comp1 = Arc::<ConstructNode<Core>>::comp(&drop, &drop).unwrap();

src/node/convert.rs

@@ -152,6 +152,10 @@ pub trait Converter<N: Marker, M: Marker> {
 /// Does not do any type-checking and may attach an invalid witness to a combinator.
 ///
 /// If it encounters a disconnect node, it simply returns an error.
+///
+/// **This finalizer should not be used in production.
+/// It introduces default values ([`Value::zero`]) to handle missing witness data,
+/// which might trigger unexpected spending paths.**
 // FIXME we should do type checking, but this would require a method to check
 // type compatibility between a Value and a type::Final.
 pub struct SimpleFinalizer<W: Iterator<Item = Value>> {
@@ -169,10 +173,13 @@ impl<W: Iterator<Item = Value>, J: Jet> Converter<Commit<J>, Redeem<J>> for Simp
 
     fn convert_witness(
         &mut self,
-        _: &PostOrderIterItem<&CommitNode<J>>,
+        data: &PostOrderIterItem<&CommitNode<J>>,
         _: &NoWitness,
     ) -> Result<Value, Self::Error> {
-        self.iter.next().ok_or(crate::Error::NoMoreWitnesses)
+        Ok(self
+            .iter
+            .next()
+            .unwrap_or_else(|| Value::zero(&data.node.arrow().target)))
     }
 
     fn convert_disconnect(

src/node/mod.rs

@@ -78,7 +78,6 @@ mod display;
 mod hiding;
 mod inner;
 mod redeem;
-mod witness;
 
 use crate::value::Word;
 pub use commit::{Commit, CommitData, CommitNode};
@@ -89,7 +88,6 @@ use display::DisplayExpr;
 pub use hiding::Hiding;
 pub use inner::Inner;
 pub use redeem::{Redeem, RedeemData, RedeemNode};
-pub use witness::{Witness, WitnessData, WitnessNode};
 
 // This trait should only be implemented on empty types, so we can demand
 // every trait bound under the sun. Doing so will make #[derive]s easier

src/node/redeem.rs

@@ -5,12 +5,12 @@ use crate::bit_machine::{ExecutionError, SetTracker};
 use crate::dag::{DagLike, InternalSharing, MaxSharing, PostOrderIterItem};
 use crate::jet::Jet;
 use crate::types::{self, arrow::FinalArrow};
-use crate::{encode, BitMachine, WitnessNode};
+use crate::{encode, BitMachine};
 use crate::{Amr, BitIter, BitWriter, Cmr, Error, FirstPassImr, Imr, Value};
 
 use super::{
-    Commit, CommitData, CommitNode, Construct, ConstructNode, Constructible, Converter, Hide,
-    Inner, Marker, NoDisconnect, NoWitness, Node, Witness, WitnessData,
+    Commit, CommitData, CommitNode, Construct, ConstructData, ConstructNode, Constructible,
+    Converter, Hide, Inner, Marker, NoDisconnect, NoWitness, Node,
 };
 
 use std::collections::HashSet;
@@ -221,15 +221,15 @@ impl<J: Jet> RedeemNode<J> {
         self.convert::<MaxSharing<Redeem<J>>, _, _>(&mut Unfinalizer(PhantomData))
     }
 
-    /// Convert a [`RedeemNode`] back into a [`WitnessNode`]
+    /// Convert a [`RedeemNode`] back into a [`ConstructNode`]
     /// by loosening the finalized types, witness data and disconnected branches.
-    pub fn to_witness_node(&self) -> Arc<WitnessNode<J>> {
-        struct ToWitness<J> {
+    pub fn to_construct_node(&self) -> Arc<ConstructNode<J>> {
+        struct ToConstruct<J> {
             inference_context: types::Context,
             phantom: PhantomData<J>,
         }
 
-        impl<J: Jet> Converter<Redeem<J>, Witness<J>> for ToWitness<J> {
+        impl<J: Jet> Converter<Redeem<J>, Construct<J>> for ToConstruct<J> {
             type Error = ();
 
             fn convert_witness(
@@ -243,31 +243,31 @@ impl<J: Jet> RedeemNode<J> {
             fn convert_disconnect(
                 &mut self,
                 _: &PostOrderIterItem<&Node<Redeem<J>>>,
-                right: Option<&Arc<Node<Witness<J>>>>,
+                right: Option<&Arc<Node<Construct<J>>>>,
                 _: &Arc<RedeemNode<J>>,
-            ) -> Result<Option<Arc<Node<Witness<J>>>>, Self::Error> {
+            ) -> Result<Option<Arc<Node<Construct<J>>>>, Self::Error> {
                 Ok(right.cloned())
             }
 
             fn convert_data(
                 &mut self,
                 _: &PostOrderIterItem<&Node<Redeem<J>>>,
                 inner: Inner<
-                    &Arc<Node<Witness<J>>>,
+                    &Arc<Node<Construct<J>>>,
                     J,
-                    &Option<Arc<WitnessNode<J>>>,
+                    &Option<Arc<ConstructNode<J>>>,
                     &Option<Value>,
                 >,
-            ) -> Result<WitnessData<J>, Self::Error> {
+            ) -> Result<ConstructData<J>, Self::Error> {
                 let inner = inner
                     .map(|node| node.cached_data())
                     .map_witness(|maybe_value| maybe_value.clone());
-                Ok(WitnessData::from_inner(&self.inference_context, inner)
+                Ok(ConstructData::from_inner(&self.inference_context, inner)
                     .expect("types were already finalized"))
             }
         }
 
-        self.convert::<InternalSharing, _, _>(&mut ToWitness {
+        self.convert::<InternalSharing, _, _>(&mut ToConstruct {
             inference_context: types::Context::new(),
             phantom: PhantomData,
         })
@@ -297,7 +297,7 @@ impl<J: Jet> RedeemNode<J> {
             phantom: PhantomData<J>,
         }
 
-        impl<J: Jet> Converter<Redeem<J>, Witness<J>> for Pruner<J> {
+        impl<J: Jet> Converter<Redeem<J>, Construct<J>> for Pruner<J> {
             type Error = std::convert::Infallible;
 
             fn convert_witness(
@@ -313,9 +313,9 @@ impl<J: Jet> RedeemNode<J> {
             fn convert_disconnect(
                 &mut self,
                 _: &PostOrderIterItem<&RedeemNode<J>>,
-                right: Option<&Arc<WitnessNode<J>>>,
+                right: Option<&Arc<ConstructNode<J>>>,
                 _: &Arc<RedeemNode<J>>,
-            ) -> Result<Option<Arc<WitnessNode<J>>>, Self::Error> {
+            ) -> Result<Option<Arc<ConstructNode<J>>>, Self::Error> {
                 debug_assert!(
                     right.is_some(),
                     "disconnected branch should exist in unpruned redeem program"
@@ -326,8 +326,8 @@ impl<J: Jet> RedeemNode<J> {
             fn prune_case(
                 &mut self,
                 data: &PostOrderIterItem<&RedeemNode<J>>,
-                _left: &Arc<WitnessNode<J>>,
-                _right: &Arc<WitnessNode<J>>,
+                _left: &Arc<ConstructNode<J>>,
+                _right: &Arc<ConstructNode<J>>,
             ) -> Result<Hide, Self::Error> {
                 // The IMR of the pruned program may change,
                 // but the Converter trait gives us access to the unpruned node (`data`).
@@ -346,25 +346,30 @@ impl<J: Jet> RedeemNode<J> {
             fn convert_data(
                 &mut self,
                 _: &PostOrderIterItem<&RedeemNode<J>>,
-                inner: Inner<&Arc<WitnessNode<J>>, J, &Option<Arc<WitnessNode<J>>>, &Option<Value>>,
-            ) -> Result<WitnessData<J>, Self::Error> {
+                inner: Inner<
+                    &Arc<ConstructNode<J>>,
+                    J,
+                    &Option<Arc<ConstructNode<J>>>,
+                    &Option<Value>,
+                >,
+            ) -> Result<ConstructData<J>, Self::Error> {
                 let converted_inner = inner
                     .map(|node| node.cached_data())
                     .map_witness(Option::<Value>::clone);
-                let retyped = WitnessData::from_inner(&self.inference_context, converted_inner)
+                let retyped = ConstructData::from_inner(&self.inference_context, converted_inner)
                     .expect("pruned types should check out if unpruned types check out");
                 Ok(retyped)
             }
         }
 
         struct Finalizer<J>(PhantomData<J>);
 
-        impl<J: Jet> Converter<Witness<J>, Redeem<J>> for Finalizer<J> {
+        impl<J: Jet> Converter<Construct<J>, Redeem<J>> for Finalizer<J> {
             type Error = std::convert::Infallible;
 
             fn convert_witness(
                 &mut self,
-                data: &PostOrderIterItem<&WitnessNode<J>>,
+                data: &PostOrderIterItem<&ConstructNode<J>>,
                 witness: &Option<Value>,
             ) -> Result<Value, Self::Error> {
                 let pruned_target_ty = data
@@ -383,9 +388,9 @@ impl<J: Jet> RedeemNode<J> {
 
             fn convert_disconnect(
                 &mut self,
-                _: &PostOrderIterItem<&WitnessNode<J>>,
+                _: &PostOrderIterItem<&ConstructNode<J>>,
                 right: Option<&Arc<RedeemNode<J>>>,
-                _: &Option<Arc<WitnessNode<J>>>,
+                _: &Option<Arc<ConstructNode<J>>>,
             ) -> Result<Arc<RedeemNode<J>>, Self::Error> {
                 Ok(right
                     .map(Arc::clone)
@@ -394,7 +399,7 @@ impl<J: Jet> RedeemNode<J> {
 
             fn convert_data(
                 &mut self,
-                data: &PostOrderIterItem<&WitnessNode<J>>,
+                data: &PostOrderIterItem<&ConstructNode<J>>,
                 inner: Inner<&Arc<RedeemNode<J>>, J, &Arc<RedeemNode<J>>, &Value>,
             ) -> Result<Arc<RedeemData<J>>, Self::Error> {
                 // Finalize target types of witness nodes in advance so we can prune their values.
@@ -457,7 +462,7 @@ impl<J: Jet> RedeemNode<J> {
             fn convert_witness(
                 &mut self,
                 data: &PostOrderIterItem<&ConstructNode<J>>,
-                _: &NoWitness,
+                _: &Option<Value>,
             ) -> Result<Value, Self::Error> {
                 let arrow = data.node.data.arrow();
                 let target_ty = arrow.target.finalize()?;

src/node/witness.rs

@@ -13,11 +13,9 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 
 use crate::jet::Elements;
-use crate::node::{
-    ConstructNode, CoreConstructible, JetConstructible, NoWitness, WitnessConstructible,
-};
+use crate::node::{ConstructNode, CoreConstructible, JetConstructible, WitnessConstructible};
 use crate::policy::serialize::{self, AssemblyConstructible};
-use crate::types;
+use crate::{types, Value};
 use crate::{Cmr, CommitNode, FailEntropy};
 use crate::{SimplicityKey, ToXOnlyPubkey, Translator};
 
@@ -63,7 +61,7 @@ impl<Pk: ToXOnlyPubkey> Policy<Pk> {
     where
         N: CoreConstructible
             + JetConstructible<Elements>
-            + WitnessConstructible<NoWitness>
+            + WitnessConstructible<Option<Value>>
             + AssemblyConstructible,
     {
         match *self {
@@ -73,12 +71,10 @@ impl<Pk: ToXOnlyPubkey> Policy<Pk> {
             Policy::Trivial => Some(serialize::trivial(inference_context)),
             Policy::After(n) => Some(serialize::after(inference_context, n)),
             Policy::Older(n) => Some(serialize::older(inference_context, n)),
-            Policy::Key(ref key) => Some(serialize::key(inference_context, key, NoWitness)),
-            Policy::Sha256(ref hash) => Some(serialize::sha256::<Pk, _, _>(
-                inference_context,
-                hash,
-                NoWitness,
-            )),
+            Policy::Key(ref key) => Some(serialize::key(inference_context, key, None)),
+            Policy::Sha256(ref hash) => {
+                Some(serialize::sha256::<Pk, _, _>(inference_context, hash, None))
+            }
             Policy::And {
                 ref left,
                 ref right,
@@ -93,17 +89,15 @@ impl<Pk: ToXOnlyPubkey> Policy<Pk> {
             } => {
                 let left = left.serialize_no_witness(inference_context)?;
                 let right = right.serialize_no_witness(inference_context)?;
-                Some(serialize::or(&left, &right, NoWitness))
+                Some(serialize::or(&left, &right, None))
             }
             Policy::Threshold(k, ref subs) => {
                 let k = u32::try_from(k).expect("can have k at most 2^32 in a threshold");
                 let subs = subs
                     .iter()
                     .map(|sub| sub.serialize_no_witness(inference_context))
                     .collect::<Option<Vec<N>>>()?;
-                let wits = iter::repeat(NoWitness)
-                    .take(subs.len())
-                    .collect::<Vec<NoWitness>>();
+                let wits = iter::repeat(None).take(subs.len()).collect::<Vec<_>>();
                 Some(serialize::threshold(k, &subs, &wits))
             }
             Policy::Assembly(cmr) => N::assembly(inference_context, cmr),

src/policy/ast.rs

@@ -2,7 +2,7 @@
 
 use crate::analysis::Cost;
 use crate::jet::Elements;
-use crate::node::{Hiding, RedeemNode, WitnessNode};
+use crate::node::{ConstructNode, Hiding, RedeemNode};
 use crate::policy::ToXOnlyPubkey;
 use crate::types;
 use crate::{Cmr, Policy, Value};
@@ -57,7 +57,7 @@ pub trait Satisfier<Pk: ToXOnlyPubkey> {
     ///
     /// If the assembly program fails to run for the current transaction environment,
     /// then implementations should return `None`.
-    fn lookup_asm_program(&self, _: Cmr) -> Option<Arc<WitnessNode<Elements>>> {
+    fn lookup_asm_program(&self, _: Cmr) -> Option<Arc<ConstructNode<Elements>>> {
         None
     }
 }
@@ -105,7 +105,7 @@ pub enum SatisfierError {
     AssemblyFailed(crate::bit_machine::ExecutionError),
 }
 
-type SatResult = Hiding<Arc<WitnessNode<Elements>>>;
+type SatResult = Hiding<Arc<ConstructNode<Elements>>>;
 
 fn ok_if(condition: bool, expr: SatResult) -> SatResult {
     match condition {
@@ -278,7 +278,7 @@ mod tests {
     pub struct PolicySatisfier<'a, Pk: SimplicityKey> {
         pub preimages: HashMap<Pk::Sha256, Preimage32>,
         pub signatures: HashMap<Pk, elements::SchnorrSig>,
-        pub assembly: HashMap<Cmr, Arc<WitnessNode<Elements>>>,
+        pub assembly: HashMap<Cmr, Arc<ConstructNode<Elements>>>,
         pub tx: &'a elements::Transaction,
         pub index: usize,
     }
@@ -305,7 +305,7 @@ mod tests {
             <elements::LockTime as Satisfier<Pk>>::check_after(&self.tx.lock_time, locktime)
         }
 
-        fn lookup_asm_program(&self, cmr: Cmr) -> Option<Arc<WitnessNode<Elements>>> {
+        fn lookup_asm_program(&self, cmr: Cmr) -> Option<Arc<ConstructNode<Elements>>> {
             self.assembly.get(&cmr).cloned()
         }
     }
@@ -681,12 +681,12 @@ mod tests {
 
         let mut assert_branch = |witness0: Value, witness1: Value| {
             let asm_program = serialize::verify_bexp(
-                &Arc::<WitnessNode<Elements>>::pair(
-                    &Arc::<WitnessNode<Elements>>::witness(&ctx, Some(witness0.clone())),
-                    &Arc::<WitnessNode<Elements>>::witness(&ctx, Some(witness1.clone())),
+                &Arc::<ConstructNode<Elements>>::pair(
+                    &Arc::<ConstructNode<Elements>>::witness(&ctx, Some(witness0.clone())),
+                    &Arc::<ConstructNode<Elements>>::witness(&ctx, Some(witness1.clone())),
                 )
                 .expect("sound types"),
-                &Arc::<WitnessNode<Elements>>::jet(&ctx, Elements::Eq8),
+                &Arc::<ConstructNode<Elements>>::jet(&ctx, Elements::Eq8),
             );
             let cmr = asm_program.cmr();
             satisfier.assembly.insert(cmr, asm_program);

src/policy/satisfy.rs

@@ -440,7 +440,7 @@ mod tests {
     use super::*;
 
     use crate::jet::Core;
-    use crate::node::{ConstructNode, CoreConstructible, WitnessNode};
+    use crate::node::{ConstructNode, CoreConstructible};
 
     #[test]
     fn inference_failure() {
@@ -464,9 +464,9 @@ mod tests {
     #[test]
     fn memory_leak() {
         let ctx = Context::new();
-        let iden = Arc::<WitnessNode<Core>>::iden(&ctx);
-        let drop = Arc::<WitnessNode<Core>>::drop_(&iden);
-        let case = Arc::<WitnessNode<Core>>::case(&iden, &drop).unwrap();
+        let iden = Arc::<ConstructNode<Core>>::iden(&ctx);
+        let drop = Arc::<ConstructNode<Core>>::drop_(&iden);
+        let case = Arc::<ConstructNode<Core>>::case(&iden, &drop).unwrap();
 
         let _ = format!("{:?}", case.arrow().source);
     }