Merge #319: jets-bench: fix multiple issues with Ctx8 encoding

934a787 jets-bench: fix multiple issues with Ctx8 encoding (Andrew Poelstra)

Pull request description:

  * changes `var_len_buf_from_slice` to interpret its `n` such that it's reading the type (2^8)^<2^n rather than (2^8)^<2^(n+1); subtract 1 from all instances of `n` except the loop counter. (Previously we were looping the wrong number of times, which this fixes.)
  * calls `var_len_buf_from_slice` with n = 6, which matches the type signature for Ctx8. Before we were calling with n = 8 which was just wrong
  * Changes `SimplicityCtx8::buffer` to have type `[u8; 64]` instead of the wrong `[u8; 512]`
  * Changes the nonsense "v.len() >= 1 << n" comparison to one that checks the bits of v.len()
  * Corrects various off-by-one errors
  
  See #318 for more information.
  
  Fixes #318


ACKs for top commit:
  canndrew:
    ACK 934a787


Tree-SHA512: 368910eab47458229b3d6a59d4a195cfed6f33a3a4031f191a33e380f5e26faad6e7b6385cb346fe8938c5919972eb7ecc00d3f7d5cc42a623c5bfd96f4e0328

Author: apoelstra

jets-bench/src/data_structures.rs

@@ -18,7 +18,7 @@ use simplicity::{
 /// length.
 #[derive(Clone)]
 pub struct SimplicityCtx8 {
-    buffer: [u8; 512],
+    buffer: [u8; 64],
     h: [u32; 8],
     length: usize,
 }
@@ -31,7 +31,7 @@ impl Default for SimplicityCtx8 {
                 0x5be0cd19,
             ],
             length: 0,
-            buffer: [0; 512],
+            buffer: [0; 64],
         }
     }
 }
@@ -45,24 +45,26 @@ impl SimplicityCtx8 {
     }
 }
 
-/// Read bytes from a Simplicity buffer of type (TWO^8)^<2^(n+1) as [`Value`].
+/// Read bytes from a Simplicity buffer of type (TWO^8)^<2^n as [`Value`].
 /// The notation X^<2 is notation for the type (S X)
 /// The notation X^<(2*n) is notation for the type S (X^n) * X^<n
 ///
-/// Cannot represent >= 2**16 bytes 0 <= n < 16 as simplicity consensus rule.
+/// There is a precondition that 0 <= n <= 16.
 ///
 /// # Panics:
 ///
-/// Panics if the length of the slice is >= 2^(n + 1) bytes
-pub fn var_len_buf_from_slice(v: &[u8], mut n: usize) -> Result<Value, EarlyEndOfStreamError> {
-    // Simplicity consensus rule for n < 16 while reading buffers.
-    assert!(n < 16);
-    assert!(v.len() < (1 << (n + 1)));
+/// Panics if the length of the slice is >= 2^n bytes or if n > 16.
+pub fn var_len_buf_from_slice(v: &[u8], n: usize) -> Result<Value, EarlyEndOfStreamError> {
+    // This precondition can probably be removed or relaxed, though
+    // we have no need to do so and it may require changing the type
+    // of 'n' to something larger.
+    assert!(n <= 16);
+    assert!(v.len() < 1 << n);
     let mut iter = BitIter::new(v.iter().copied());
     let mut res = None;
-    while n > 0 {
-        let ty = Final::two_two_n(n);
-        let v = if v.len() >= (1 << (n + 1)) {
+    for i in (0..n).rev() {
+        let ty = Final::two_two_n(i + 3);
+        let v = if v.len() & 1 << i != 0 {
             let val = Value::from_compact_bits(&mut iter, &ty)?;
             Value::some(val)
         } else {
@@ -72,8 +74,8 @@ pub fn var_len_buf_from_slice(v: &[u8], mut n: usize) -> Result<Value, EarlyEndO
             Some(prod) => Some(Value::product(prod, v)),
             None => Some(v),
         };
-        n -= 1;
     }
+    assert_eq!(iter.next(), None);
     Ok(res.unwrap_or(Value::unit()))
 }
 
@@ -157,8 +159,8 @@ pub trait SimplicityEncode {
 
 impl SimplicityEncode for SimplicityCtx8 {
     fn value(&self) -> Value {
-        let buf_len = self.length % 512;
-        let buf = var_len_buf_from_slice(&self.buffer[..buf_len], 8).unwrap();
+        let buf_len = self.length % 64;
+        let buf = var_len_buf_from_slice(&self.buffer[..buf_len], 6).unwrap();
         let len = Value::u64(self.length as u64);
         // convert to 32 byte array
         let mut arr = [0u8; 32];