Add bindings for DAGs and tests

Author: uncomputable

simplicity-sys/src/bitstream.rs

@@ -0,0 +1,53 @@
+// Simplicity Bindings
+// Written in 2022 by
+//   Christian Lewe <clewe@blockstream.com>
+//
+// 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 libc::{c_char, c_int, c_uchar, c_void, FILE};
+use std::marker::PhantomData;
+
+/// Stream of bits.
+#[repr(C)]
+pub struct Bitstream<'a> {
+    file: *mut FILE,
+    available: c_int,
+    byte: c_uchar,
+    _marker: PhantomData<&'a u8>,
+}
+
+impl<'a> From<&'a [u8]> for Bitstream<'a> {
+    fn from(bytes: &'a [u8]) -> Self {
+        unsafe {
+            let mode = "r";
+            let file = libc::fmemopen(
+                bytes.as_ptr() as *mut c_void,
+                bytes.len(),
+                mode.as_ptr() as *const c_char,
+            );
+
+            Bitstream {
+                file,
+                available: 0,
+                byte: c_uchar::default(),
+                _marker: PhantomData,
+            }
+        }
+    }
+}
+
+impl<'a> Drop for Bitstream<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            libc::fclose(self.file);
+        }
+    }
+}

simplicity-sys/src/bitstring.rs

@@ -0,0 +1,24 @@
+// Simplicity Bindings
+// Written in 2022 by
+//   Christian Lewe <clewe@blockstream.com>
+//
+// 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 libc::{c_uchar, size_t};
+
+/// String of bits.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub(crate) struct Bitstring {
+    arr: *const c_uchar,
+    len: size_t,
+    offset: size_t,
+}

simplicity-sys/src/dag.rs

@@ -0,0 +1,152 @@
+// Simplicity Bindings
+// Written in 2022 by
+//   Christian Lewe <clewe@blockstream.com>
+//
+// 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::bitstream::Bitstream;
+use crate::bitstring::Bitstring;
+use crate::error::Error;
+use crate::util;
+use libc::{c_void, size_t};
+use std::fmt;
+
+/// Kind of Simplicity node.
+#[repr(C)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Tag {
+    COMP,
+    CASE,
+    ASSERTL,
+    ASSERTR,
+    PAIR,
+    DISCONNECT,
+    INJL,
+    INJR,
+    TAKE,
+    DROP,
+    IDEN,
+    UNIT,
+    HIDDEN,
+    WITNESS,
+    JET,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+union AuxTypes {
+    /// scratch space for verifyCanonicalOrder
+    aux: size_t,
+    /// source type, target type
+    types: [size_t; 2],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+union IndicesChildrenWitness {
+    /// source index, target index
+    indices: [size_t; 2],
+    /// first child, second child
+    children: [size_t; 2],
+    /// witness
+    witness: Bitstring,
+}
+
+#[repr(C)]
+struct PrivateDagNode {
+    jet: *const c_void,
+    cmr: [u32; 8],
+    aux_types: AuxTypes,
+    indices_children_witness: IndicesChildrenWitness,
+    tag: Tag,
+}
+
+extern "C" {
+    fn decodeMallocDag(
+        dag: *mut *mut PrivateDagNode,
+        combinator_counters: *const c_void,
+        stream: *mut Bitstream,
+    ) -> i32;
+}
+
+/// Simplicity DAG (typed or untyped).
+/// Uses the Elements extension by default.
+pub struct Dag {
+    first: *mut PrivateDagNode,
+    len: usize,
+}
+
+impl fmt::Debug for Dag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Dag").field("cmr", &self.cmr()).finish()
+    }
+}
+
+impl Dag {
+    /// Decode a Simplicity DAG from bytes.
+    pub fn decode(bytes: &[u8]) -> Result<Self, Error> {
+        let mut bitstream = Bitstream::from(bytes);
+        let mut dag: *mut PrivateDagNode = std::ptr::null_mut();
+
+        unsafe {
+            let len =
+                Error::get_result(decodeMallocDag(&mut dag, std::ptr::null(), &mut bitstream))?;
+
+            if dag.is_null() {
+                Err(Error::Malloc)
+            } else {
+                Ok(Dag {
+                    first: dag,
+                    len: len as usize,
+                })
+            }
+        }
+    }
+
+    /// Return the CMR of the DAG.
+    pub fn cmr(&self) -> [u8; 32] {
+        unsafe { util::into_u8_merkle_root(&(*self.root_node()).cmr) }
+    }
+
+    /// Return the root node of the DAG.
+    unsafe fn root_node(&self) -> *const PrivateDagNode {
+        self.get(self.len - 1)
+    }
+
+    // TODO: Add notion of `DagNode<'a>` that is spawned by &'a self
+    // and that enables read-only access to node fields
+    /// Return the node at the given `index` in the DAG.
+    /// Panics if `index` is out of bounds.
+    unsafe fn get(&self, index: usize) -> *const PrivateDagNode {
+        self.first.add(index)
+    }
+}
+
+impl Drop for Dag {
+    fn drop(&mut self) {
+        unsafe {
+            libc::free(self.first as *mut libc::c_void);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test::SCHNORR0;
+
+    #[test]
+    fn decode_cmr() {
+        let bytes = SCHNORR0.bytes;
+        let dag = Dag::decode(bytes).expect("decoding");
+        assert_eq!(SCHNORR0.cmr(), dag.cmr());
+    }
+}

simplicity-sys/src/error.rs

@@ -0,0 +1,45 @@
+// Simplicity Bindings
+// Written in 2022 by
+//   Christian Lewe <clewe@blockstream.com>
+//
+// 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/>.
+//
+
+/// Simplicity error.
+#[derive(Debug)]
+pub enum Error {
+    Malloc,
+    BitstreamEOF,
+    BitstreamError,
+    DataOutOfRange,
+    NotYetImplemented,
+    DataOutOfOrder,
+    FailCode,
+    StopCode,
+    Hidden,
+}
+
+impl Error {
+    pub(crate) fn get_result(ret: i32) -> Result<i32, Error> {
+        match ret {
+            i if i >= 0 => Ok(i),
+            -1 => Err(Error::Malloc),
+            -2 => Err(Error::BitstreamEOF),
+            -3 => Err(Error::BitstreamError),
+            -4 => Err(Error::DataOutOfRange),
+            -5 => Err(Error::NotYetImplemented),
+            -6 => Err(Error::DataOutOfOrder),
+            -8 => Err(Error::FailCode),
+            -10 => Err(Error::StopCode),
+            -12 => Err(Error::Hidden),
+            i => panic!("Unexpected error code: {}", i),
+        }
+    }
+}

simplicity-sys/src/lib.rs

@@ -11,3 +11,10 @@
 // along with this software.
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
+
+mod bitstream;
+mod bitstring;
+pub mod dag;
+pub mod error;
+pub mod test;
+mod util;

simplicity-sys/src/test.rs

@@ -0,0 +1,84 @@
+// Simplicity Bindings
+// Written in 2022 by
+//   Christian Lewe <clewe@blockstream.com>
+//
+// 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::util;
+
+extern "C" {
+    static schnorr0: [u8; 257];
+    static schnorr0_cmr: [u32; 8];
+    static schnorr0_imr: [u32; 8];
+
+    static schnorr6: [u8; 405];
+    static schnorr6_cmr: [u32; 8];
+    static schnorr6_imr: [u32; 8];
+
+    static hashBlock: [u8; 3259];
+    static hashBlock_cmr: [u32; 8];
+    static hashBlock_imr: [u32; 8];
+
+    static elementsCheckSigHashAllTx1: [u8; 1151];
+    static elementsCheckSigHashAllTx1_cmr: [u32; 8];
+    static elementsCheckSigHashAllTx1_imr: [u32; 8];
+}
+
+/// Simplicity program with bytes, CMR and IMR for testing.
+pub struct TestProgram {
+    pub bytes: &'static [u8],
+    pub(crate) cmr: &'static [u32; 8],
+    pub(crate) imr: &'static [u32; 8],
+}
+
+impl TestProgram {
+    /// Return the CMR of the given program.
+    pub fn cmr(&self) -> [u8; 32] {
+        util::into_u8_merkle_root(self.cmr)
+    }
+
+    /// Return the IMR of the given program.
+    pub fn imr(&self) -> [u8; 32] {
+        util::into_u8_merkle_root(self.imr)
+    }
+}
+
+pub static SCHNORR0: TestProgram = unsafe {
+    TestProgram {
+        bytes: &schnorr0,
+        cmr: &schnorr0_cmr,
+        imr: &schnorr0_imr,
+    }
+};
+
+pub static SCHNORR6: TestProgram = unsafe {
+    TestProgram {
+        bytes: &schnorr6,
+        cmr: &schnorr6_cmr,
+        imr: &schnorr6_imr,
+    }
+};
+
+pub static HASHBLOCK: TestProgram = unsafe {
+    TestProgram {
+        bytes: &hashBlock,
+        cmr: &hashBlock_cmr,
+        imr: &hashBlock_imr,
+    }
+};
+
+pub static ELEMENTS_CHECK_SIGHASH_ALL_TX1: TestProgram = unsafe {
+    TestProgram {
+        bytes: &elementsCheckSigHashAllTx1,
+        cmr: &elementsCheckSigHashAllTx1_cmr,
+        imr: &elementsCheckSigHashAllTx1_imr,
+    }
+};

simplicity-sys/src/util.rs

@@ -0,0 +1,9 @@
+pub(crate) fn into_u8_merkle_root(u32_merkle_root: &[u32; 8]) -> [u8; 32] {
+    let mut u8_merkle_root = [0; 32];
+
+    for i in 0..8 {
+        u8_merkle_root[i * 4..i * 4 + 4].copy_from_slice(&u32_merkle_root[i].to_be_bytes());
+    }
+
+    u8_merkle_root
+}