Add Node

Author: uncomputable

src/core/mod.rs

@@ -18,9 +18,12 @@
 //! Defines Simplicity terms, values, types, DAGs and programs.
 
 // pub mod iter;
-// pub mod types;
 pub mod commit;
+pub mod node;
+#[allow(dead_code)]
+pub mod types;
 mod value;
 
 pub use commit::CommitNode;
+pub use node::Node;
 pub use value::Value;

src/core/node.rs

@@ -0,0 +1,144 @@
+// Rust Simplicity Library
+// Written in 2022 by
+//   Christian Lewe <[email protected]>
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+use crate::core::types::Type;
+use crate::jet::{Application, JetNode};
+use crate::merkle::cmr::Cmr;
+use crate::merkle::imr::Imr;
+use std::rc::Rc;
+use std::sync::Arc;
+
+/// Underlying combinator of a [`Node`].
+///
+/// # See
+/// - [`crate::core::commit::CommitNodeInner`]
+#[derive(Debug)]
+pub enum NodeInner<Witness, App: Application> {
+    /// Identity
+    Iden,
+    /// Unit constant
+    Unit,
+    /// Left injection of some child
+    InjL(Rc<Node<Witness, App>>),
+    /// Right injection of some child
+    InjR(Rc<Node<Witness, App>>),
+    /// Take of some child
+    Take(Rc<Node<Witness, App>>),
+    /// Drop of some child
+    Drop(Rc<Node<Witness, App>>),
+    /// Composition of a left and right child
+    Comp(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Case of a left and right child
+    Case(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Left assertion of a left and right child.
+    AssertL(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Right assertion of a left and right child.
+    AssertR(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Pair of a left and right child
+    Pair(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Disconnect of a left and right child
+    Disconnect(Rc<Node<Witness, App>>, Rc<Node<Witness, App>>),
+    /// Witness data
+    Witness(Witness),
+    /// Universal fail
+    Fail(Cmr, Cmr),
+    /// Hidden CMR
+    Hidden(Cmr),
+    /// Application jet
+    Jet(&'static JetNode<App>),
+}
+
+#[allow(dead_code)]
+/// Source and target type of a node
+#[derive(Debug)]
+pub struct NodeType {
+    /// Source type of the node
+    pub(crate) source: Arc<Type>,
+    /// Target type of the node
+    pub(crate) target: Arc<Type>,
+}
+
+/// Bounds on the resources required by a node during execution on the Bit Machine
+#[derive(Debug)]
+pub struct NodeBounds {
+    /// Upper bound on the required number of cells
+    pub extra_cells: usize,
+    /// Upper bound on the required number of frames
+    pub frame_count: usize,
+}
+
+/// Root node of a Simplicity DAG for some application.
+/// The DAG contains full metadata, including the witness, for redeeming it.
+///
+/// # See
+/// - [`crate::core::CommitNode`]
+#[derive(Debug)]
+pub struct Node<Witness, App: Application> {
+    /// Underlying combinator of the node
+    pub inner: NodeInner<Witness, App>,
+    /// Commitment Merkle root of the node
+    pub cmr: Cmr,
+    /// Identity Merkle root of the node
+    pub imr: Imr,
+    /// Type of the node
+    pub ty: NodeType,
+    /// Bounds for the node during execution on the Bit Machine
+    pub bounds: NodeBounds,
+}
+
+impl<Witness, App: Application> Node<Witness, App> {
+    /// Return the left child of the node, if there is such a child.
+    pub fn get_left(&self) -> Option<&Self> {
+        match &self.inner {
+            NodeInner::Iden
+            | NodeInner::Unit
+            | NodeInner::Witness(_)
+            | NodeInner::Fail(_, _)
+            | NodeInner::Hidden(_)
+            | NodeInner::Jet(_) => None,
+            NodeInner::InjL(l)
+            | NodeInner::InjR(l)
+            | NodeInner::Take(l)
+            | NodeInner::Drop(l)
+            | NodeInner::Comp(l, _)
+            | NodeInner::Case(l, _)
+            | NodeInner::AssertL(l, _)
+            | NodeInner::AssertR(l, _)
+            | NodeInner::Pair(l, _)
+            | NodeInner::Disconnect(l, _) => Some(l),
+        }
+    }
+
+    /// Return the right child of the node, if there is such a child.
+    pub fn get_right(&self) -> Option<&Self> {
+        match &self.inner {
+            NodeInner::Iden
+            | NodeInner::Unit
+            | NodeInner::Witness(_)
+            | NodeInner::Fail(_, _)
+            | NodeInner::Hidden(_)
+            | NodeInner::Jet(_)
+            | NodeInner::InjL(_)
+            | NodeInner::InjR(_)
+            | NodeInner::Take(_)
+            | NodeInner::Drop(_) => None,
+            NodeInner::Comp(_, r)
+            | NodeInner::Case(_, r)
+            | NodeInner::AssertL(_, r)
+            | NodeInner::AssertR(_, r)
+            | NodeInner::Pair(_, r)
+            | NodeInner::Disconnect(_, r) => Some(r),
+        }
+    }
+}

src/jet/mod.rs

@@ -34,11 +34,11 @@ pub mod type_name;
 
 use crate::bititer::BitIter;
 use crate::encode::BitWriter;
+use crate::exec::BitMachine;
 use crate::jet::type_name::TypeName;
 use crate::merkle::cmr::Cmr;
-// use crate::merkle::common::MerkleRoot;
-// use crate::merkle::imr::Imr;
-use crate::exec::BitMachine;
+use crate::merkle::common::MerkleRoot;
+use crate::merkle::imr::Imr;
 use std::hash::Hash;
 use std::io::Write;
 
@@ -105,15 +105,13 @@ impl<App: Application> JetNode<App> {
         self.cmr
     }
 
-    /*
     /// Return the IMR of the jet.
     ///
     /// A jet's CMR equals its IMR.
     /// Jets may not include `witness` or `disconnect` nodes as a result.
     pub fn imr(&self) -> Imr {
         self.cmr.into_inner().into()
     }
-    */
 }
 
 impl<App: Application> std::fmt::Display for JetNode<App> {

src/merkle/common.rs

@@ -14,9 +14,11 @@
 
 //! # Common traits and macros
 
-// use crate::core::types::{Type, TypeInner};
 use crate::core::commit::CommitNodeInner;
+use crate::core::types::{Type, TypeInner};
+use crate::core::Value;
 use crate::jet::Application;
+use crate::util::u64_to_array_be;
 use bitcoin_hashes::sha256::Midstate;
 use bitcoin_hashes::{sha256, Hash, HashEngine};
 
@@ -64,7 +66,6 @@ pub trait MerkleRoot: From<[u8; 32]> + Into<[u8; 32]> {
         Self::from(engine.midstate().into_inner())
     }
 
-    /*
     /// Extend the given tagged hash by the hash of the given `value` and the TMR of its `value_type`.
     ///
     /// The hash `self` is taken as initial value,
@@ -116,7 +117,6 @@ pub trait MerkleRoot: From<[u8; 32]> + Into<[u8; 32]> {
         engine.input(value_type.tmr.as_ref());
         Self::from(engine.midstate().into_inner())
     }
-    */
 
     /// Converts the given tagged hash into a byte array
     fn into_inner(self) -> [u8; 32] {
@@ -133,7 +133,6 @@ pub trait CommitMerkleRoot: MerkleRoot {
     fn get_iv<Witness, App: Application>(node: &CommitNodeInner<Witness, App>) -> Self;
 }
 
-/*
 /// Tagged SHA256 hash used for [`Type`]
 pub trait TypeMerkleRoot: MerkleRoot {
     /// Return the initial value for the given type.
@@ -142,7 +141,6 @@ pub trait TypeMerkleRoot: MerkleRoot {
     /// and returned as initial value
     fn get_iv(ty: &TypeInner) -> Self;
 }
-*/
 
 /// Convenience macro for wrappers of `Midstate`.
 ///

src/merkle/imr.rs

@@ -18,49 +18,65 @@
 //! In contrast to [`super::cmr`], `witness` data and both `disconnect` branches are included in the hash.
 //! The type of `witness` data is included in the hash via [`super::tmr`].
 
-use crate::core::{ProgramNode, Term, TypedNode, Value};
+use crate::core::commit::CommitNodeInner;
+use crate::core::node::NodeType;
+use crate::core::{Node, Value};
 use crate::impl_midstate_wrapper;
 use crate::jet::Application;
 use crate::merkle::cmr::Cmr;
-use crate::merkle::common::{MerkleRoot, TermMerkleRoot};
+use crate::merkle::common::{CommitMerkleRoot, MerkleRoot};
 use bitcoin_hashes::sha256::Midstate;
+use std::rc::Rc;
 
 /// Identity Merkle root
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Imr(Midstate);
 
 impl_midstate_wrapper!(Imr);
 
-impl TermMerkleRoot for Imr {
-    fn get_iv<Witness, App: Application>(term: &Term<Witness, App>) -> Self {
-        match term {
-            Term::Disconnect(..) => Imr::tag_iv(b"Simplicity-Draft\x1fIdentity\x1fdisconnect"),
-            Term::Witness(..) => Imr::tag_iv(b"Simplicity-Draft\x1fIdentity\x1fwitness"),
-            _ => Cmr::get_iv(term).into_inner().into(),
+impl CommitMerkleRoot for Imr {
+    fn get_iv<Witness, App: Application>(node: &CommitNodeInner<Witness, App>) -> Self {
+        match node {
+            CommitNodeInner::Disconnect(_, _) => {
+                Imr::tag_iv(b"Simplicity-Draft\x1fIdentity\x1fdisconnect")
+            }
+            CommitNodeInner::Witness(_) => Imr::tag_iv(b"Simplicity-Draft\x1fIdentity\x1fwitness"),
+            _ => Cmr::get_iv(node).into_inner().into(),
         }
     }
 }
 
-/// Compute the IMR of the given `node` that will be appended to the given `program`
-/// at the given `index`.
-pub(crate) fn compute_imr<App: Application>(
-    program: &[ProgramNode<App>],
-    node: &TypedNode<Value, App>,
-    index: usize,
+#[allow(dead_code)]
+/// Compute the IMR of the given node (once finalized).
+///
+/// Nodes with left children require their finalized left child,
+/// while nodes with right children require their finalized right child.
+/// Witness nodes require their value and node type.
+pub(crate) fn compute_imr<Witness, App: Application>(
+    node: &CommitNodeInner<Witness, App>,
+    left: Option<Rc<Node<Value, App>>>,
+    right: Option<Rc<Node<Value, App>>>,
+    value: Option<&Value>,
+    ty: &NodeType,
 ) -> Imr {
-    let imr_iv = Imr::get_iv(&node.term);
+    let imr_iv = Imr::get_iv(node);
 
-    match node.term {
-        Term::Iden | Term::Unit | Term::Fail(..) | Term::Hidden(..) | Term::Jet(..) => imr_iv,
-        Term::InjL(i) | Term::InjR(i) | Term::Take(i) | Term::Drop(i) => {
-            imr_iv.update_1(program[index - i].imr)
-        }
-        Term::Comp(i, j)
-        | Term::Case(i, j)
-        | Term::Pair(i, j)
-        | Term::AssertL(i, j)
-        | Term::AssertR(i, j)
-        | Term::Disconnect(i, j) => imr_iv.update(program[index - i].imr, program[index - j].imr),
-        Term::Witness(ref value) => imr_iv.update_value(value, &node.target_ty),
+    match node {
+        CommitNodeInner::Iden
+        | CommitNodeInner::Unit
+        | CommitNodeInner::Fail(..)
+        | CommitNodeInner::Hidden(..)
+        | CommitNodeInner::Jet(..) => imr_iv,
+        CommitNodeInner::InjL(_)
+        | CommitNodeInner::InjR(_)
+        | CommitNodeInner::Take(_)
+        | CommitNodeInner::Drop(_)
+        | CommitNodeInner::Disconnect(_, _) => imr_iv.update_1(left.unwrap().imr),
+        CommitNodeInner::Comp(_, _)
+        | CommitNodeInner::Case(_, _)
+        | CommitNodeInner::Pair(_, _)
+        | CommitNodeInner::AssertL(_, _)
+        | CommitNodeInner::AssertR(_, _) => imr_iv.update(left.unwrap().imr, right.unwrap().imr),
+        CommitNodeInner::Witness(_) => imr_iv.update_value(value.unwrap(), ty.target.as_ref()),
     }
 }

src/merkle/mod.rs

@@ -19,5 +19,5 @@
 
 pub mod cmr;
 pub mod common;
-// pub mod imr;
-// pub mod tmr;
+pub mod imr;
+pub mod tmr;