simplicity-sys: update libsimplicity to 1b85dc31d80d36dc012755e4369ae…

…eac815476a6

This separates out the witness data from the program data. This commit
updates simplicity-sys and libsimplicity, and gets all the tests
passing, but does not update the main library for the new serialization.
Therefore the existing tests pass but the c_rust_merkle fuzztest will not.

Also fixes the binding to closeBitstream in the FFI test harness, which
I had forgotten to do back in BlockstreamResearch#102.

The next commit updates the main library.

fuzz/fuzz_targets/c_rust_merkle.rs

@@ -8,9 +8,22 @@ use simplicity::jet::Elements;
 use simplicity::{BitIter, RedeemNode};
 
 fn do_test(data: &[u8]) {
-    let c_result = run_program(data, TestUpTo::CheckOneOne);
+    if data.len() < 4 {
+        return;
+    }
+    let prog_len = (usize::from(data[0]) << 24)
+        + (usize::from(data[1]) << 16)
+        + (usize::from(data[2]) << 8)
+        + usize::from(data[3]);
+    if prog_len >= data.len() {
+        return;
+    }
+    let data = &data[4..];
+
+    let (program, witness) = data.split_at(prog_len);
+    let c_result = run_program(program, witness, TestUpTo::CheckOneOne);
 
-    let mut iter = BitIter::from(data);
+    let mut iter = BitIter::from(program);
     let rust_result = RedeemNode::<Elements>::decode(&mut iter);
 
     match (c_result, rust_result) {

simplicity-sys/depend/simplicity-HEAD-revision.txt

@@ -1,2 +1,2 @@
 # This file has been automatically generated.
-952e126256dd31d7ed8f4b33b99ae8cd1edabe89
+1b85dc31d80d36dc012755e4369aeeac815476a6

simplicity-sys/depend/simplicity/cmr.c

@@ -33,7 +33,7 @@ bool simplicity_computeCmr( simplicity_err* error, unsigned char* cmr
   } else {
     simplicity_assert(NULL != dag);
     simplicity_assert((size_t)dag_len <= DAG_LEN_MAX);
-    *error = SIMPLICITY_NO_ERROR;
+    *error = closeBitstream(&stream);
     sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s);
   }
 

simplicity-sys/depend/simplicity/ctx8Pruned.c

@@ -260,6 +260,11 @@ const unsigned char ctx8Pruned[] = {
 };
 
 const size_t sizeof_ctx8Pruned = sizeof(ctx8Pruned);
+const unsigned char ctx8Pruned_witness[] = {
+
+};
+
+const size_t sizeof_ctx8Pruned_witness = sizeof(ctx8Pruned_witness);
 
 /* The commitment Merkle root of the above ctx8Pruned Simplicity expression. */
 const uint32_t ctx8Pruned_cmr[] = {

simplicity-sys/depend/simplicity/ctx8Pruned.h

@@ -12,6 +12,8 @@
  */
 extern const unsigned char ctx8Pruned[];
 extern const size_t sizeof_ctx8Pruned;
+extern const unsigned char ctx8Pruned_witness[];
+extern const size_t sizeof_ctx8Pruned_witness;
 
 /* The commitment Merkle root of the above ctx8Pruned Simplicity expression. */
 extern const uint32_t ctx8Pruned_cmr[];

simplicity-sys/depend/simplicity/ctx8Unpruned.c

@@ -250,6 +250,11 @@ const unsigned char ctx8Unpruned[] = {
 };
 
 const size_t sizeof_ctx8Unpruned = sizeof(ctx8Unpruned);
+const unsigned char ctx8Unpruned_witness[] = {
+
+};
+
+const size_t sizeof_ctx8Unpruned_witness = sizeof(ctx8Unpruned_witness);
 
 /* The commitment Merkle root of the above ctx8Unpruned Simplicity expression. */
 const uint32_t ctx8Unpruned_cmr[] = {

simplicity-sys/depend/simplicity/ctx8Unpruned.h

@@ -12,6 +12,8 @@
  */
 extern const unsigned char ctx8Unpruned[];
 extern const size_t sizeof_ctx8Unpruned;
+extern const unsigned char ctx8Unpruned_witness[];
+extern const size_t sizeof_ctx8Unpruned_witness;
 
 /* The commitment Merkle root of the above ctx8Unpruned Simplicity expression. */
 extern const uint32_t ctx8Unpruned_cmr[];

simplicity-sys/depend/simplicity/dag.c

@@ -472,31 +472,31 @@ simplicity_err verifyCanonicalOrder(dag_node* dag, const size_t len) {
 /* This function fills in the 'WITNESS' nodes of a 'dag' with the data from 'witness'.
  * For each 'WITNESS' : A |- B expression in 'dag', the bits from the 'witness' bitstring are decoded in turn
  * to construct a compact representation of a witness value of type B.
- * This function only returns 'SIMPLICITY_NO_ERROR' when exactly 'witness.len' bits are consumed by all the 'dag's witness values.
- * If extra bits remain, then 'SIMPLICITY_ERR_WITNESS_TRAILING_BITS' is returned.
  * If there are not enough bits, then 'SIMPLICITY_ERR_WITNESS_EOF' is returned.
- *
- * Note: the 'witness' value is passed by copy because the implementation manipulates a local copy of the structure.
+ * If a witness node would end up with more than CELLS_MAX bits, then 'SIMPLICITY_ERR_EXEC_MEMORY' is returned.
+ * Otherwise, returns 'SIMPLICITY_NO_ERROR'.
  *
  * Precondition: dag_node dag[len] and 'dag' without witness data and is well-typed with 'type_dag';
- *               witness is a valid bitstring;
+ *               witness is a valid bitstream;
  *
  * Postcondition: dag_node dag[len] and 'dag' has witness data and is well-typed with 'type_dag'
  *                  when the result is 'SIMPLICITY_NO_ERROR';
  */
-simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len, bitstring witness) {
+simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len, bitstream *witness) {
+  static_assert(CELLS_MAX <= 0x80000000, "CELLS_MAX is too large.");
   for (size_t i = 0; i < len; ++i) {
     if (WITNESS == dag[i].tag) {
-      if (witness.len <= 0) {
-        /* There is no more data left in witness. */
+      if (CELLS_MAX < type_dag[WITNESS_B(dag, type_dag, i)].bitSize) return SIMPLICITY_ERR_EXEC_MEMORY;
+      if (witness->len <= 0) {
+        /* There is no data in the witness. */
         dag[i].compactValue = (bitstring){0};
         /* This is fine as long as the witness type is trivial */
         if (type_dag[WITNESS_B(dag, type_dag, i)].bitSize) return SIMPLICITY_ERR_WITNESS_EOF;
       } else {
         dag[i].compactValue = (bitstring)
-          { .arr = &witness.arr[witness.offset/CHAR_BIT]
-          , .offset = witness.offset % CHAR_BIT
-          , .len = witness.len /* The value of .len will be finalized after the while loop. */
+          { .arr = witness->arr
+          , .offset = witness->offset
+          , .len = 0 /* The value of .len will computed within the while loop. */
           };
 
         /* Traverse the witness type to parse the witness's compact representation as a bit string. */
@@ -507,9 +507,9 @@ simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len,
           if (SUM == type_dag[cur].kind) {
             /* Parse one bit and traverse the left type or the right type depending on the value of the bit parsed. */
             simplicity_assert(calling);
-            if (witness.len <= 0) return SIMPLICITY_ERR_WITNESS_EOF;
-            bool bit = 1 & (witness.arr[witness.offset/CHAR_BIT] >> (CHAR_BIT - 1 - witness.offset % CHAR_BIT));
-            witness.offset++; witness.len--;
+            int32_t bit = read1Bit(witness);
+            if (bit < 0) return SIMPLICITY_ERR_WITNESS_EOF;
+            dag[i].compactValue.len++;
             size_t next = typeSkip(type_dag[cur].typeArg[bit], type_dag);
             if (next) {
               type_dag[next].back = type_dag[cur].back;
@@ -542,10 +542,6 @@ simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len,
             }
           }
         }
-        /* The length of this 'WITNESS' node's witness value is
-         * the difference between the remaining witness length from before and after parsing.
-         */
-        dag[i].compactValue.len -= witness.len;
 
         /* Note: Above we use 'typeSkip' to skip over long chains of products against trivial types
          * This avoids a potential DOS vulnerability where a DAG of deeply nested products of unit types with sharing is traversed,
@@ -558,7 +554,7 @@ simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len,
       }
     }
   }
-  return 0 == witness.len ? SIMPLICITY_NO_ERROR : SIMPLICITY_ERR_WITNESS_TRAILING_BITS;
+  return SIMPLICITY_NO_ERROR;
 }
 
 /* Verifies that identity Merkle roots of every subexpression in a well-typed 'dag' with witnesses are all unique,

simplicity-sys/depend/simplicity/dag.h

@@ -7,6 +7,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <simplicity/errorCodes.h>
+#include "bitstream.h"
 #include "bitstring.h"
 #include "bounded.h"
 #include "jets.h"
@@ -364,17 +365,17 @@ simplicity_err verifyCanonicalOrder(dag_node* dag, const size_t len);
 /* This function fills in the 'WITNESS' nodes of a 'dag' with the data from 'witness'.
  * For each 'WITNESS' : A |- B expression in 'dag', the bits from the 'witness' bitstring are decoded in turn
  * to construct a compact representation of a witness value of type B.
- * This function only returns 'SIMPLICITY_NO_ERROR' when exactly 'witness.len' bits are consumed by all the 'dag's witness values.
- * If extra bits remain, then 'SIMPLICITY_ERR_WITNESS_TRAILING_BITS' is returned.
  * If there are not enough bits, then 'SIMPLICITY_ERR_WITNESS_EOF' is returned.
+ * If a witness node would end up with more than CELLS_MAX bits, then 'SIMPLICITY_ERR_EXEC_MEMORY' is returned.
+ * Otherwise, returns 'SIMPLICITY_NO_ERROR'.
  *
  * Precondition: dag_node dag[len] and 'dag' without witness data and is well-typed with 'type_dag';
- *               witness is a valid bitstring;
+ *               witness is a valid bitstream;
  *
  * Postcondition: dag_node dag[len] and 'dag' has witness data and is well-typed with 'type_dag'
  *                  when the result is 'SIMPLICITY_NO_ERROR';
  */
-simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len, bitstring witness);
+simplicity_err fillWitnessData(dag_node* dag, type* type_dag, const size_t len, bitstream *witness);
 
 /* Verifies that identity Merkle roots of every subexpression in a well-typed 'dag' with witnesses are all unique,
  * including that each hidden root hash for every 'HIDDEN' node is unique.

simplicity-sys/depend/simplicity/deserialize.c

@@ -215,24 +215,3 @@ int32_t decodeMallocDag(dag_node** dag, combinator_counters* census, bitstream*
     return (int32_t)error;
   }
 }
-
-/* Decode a string of up to 2^31 - 1 bits from 'stream'.
- * This is the format in which the data for 'WITNESS' nodes are encoded.
- * Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the encoded string of bits exceeds this decoder's limits.
- * Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'.
- * If successful, '*witness' is set to the decoded bitstring,
- *                and 'SIMPLICITY_NO_ERROR' is returned.
- *
- * If an error is returned '*witness' might be modified.
- *
- * Precondition: NULL != witness;
- *               NULL != stream;
- */
-simplicity_err decodeWitnessData(bitstring* witness, bitstream* stream) {
-  int32_t witnessLen = read1Bit(stream);
-  if (witnessLen < 0) return (simplicity_err)witnessLen;
-  if (0 < witnessLen) witnessLen = decodeUptoMaxInt(stream);
-  if (witnessLen < 0) return (simplicity_err)witnessLen;
-
-  return readBitstring(witness, (size_t)witnessLen, stream);
-}

simplicity-sys/depend/simplicity/deserialize.h

@@ -30,18 +30,4 @@
  */
 int32_t decodeMallocDag(dag_node** dag, combinator_counters* census, bitstream* stream);
 
-/* Decode a string of up to 2^31 - 1 bits from 'stream'.
- * This is the format in which the data for 'WITNESS' nodes are encoded.
- * Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the encoded string of bits exceeds this decoder's limits.
- * Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'.
- * If successful, '*witness' is set to the decoded bitstring,
- *                and 'SIMPLICITY_NO_ERR' is returned.
- *
- * If an error is returned '*witness' might be modified.
- *
- * Precondition: NULL != witness;
- *               NULL != stream;
- */
-simplicity_err decodeWitnessData(bitstring* witness, bitstream* stream);
-
 #endif

simplicity-sys/depend/simplicity/hashBlock.c

@@ -166,10 +166,15 @@ const unsigned char hashBlock[] = {
   0x1b, 0xa4, 0xa6, 0x7e, 0x92, 0xa0, 0xa0, 0x0e, 0xa3, 0x00, 0x58, 0x8d, 0xd2, 0xe7, 0x30, 0xf0, 0x50, 0x07, 0x51, 0x8c,
   0x6e, 0x96, 0x31, 0xfa, 0x58, 0xe2, 0x80, 0x3a, 0x8c, 0xa1, 0x62, 0x16, 0xb1, 0xba, 0x59, 0x67, 0xe9, 0x66, 0x0a, 0x00,
   0xea, 0x34, 0x0d, 0xd2, 0x61, 0x3f, 0x49, 0x88, 0x50, 0x07, 0x51, 0xa8, 0x2c, 0x46, 0xe9, 0x20, 0x1f, 0xa4, 0x82, 0x28,
-  0x03, 0xa8, 0xd9, 0x17, 0x49, 0x83, 0xa4, 0xb2, 0x07, 0x51, 0xb6, 0x2a, 0x16, 0x80, 0xb8, 0x10, 0x1c, 0x4a, 0x00
+  0x03, 0xa8, 0xd9, 0x17, 0x49, 0x83, 0xa4, 0xb2, 0x07, 0x51, 0xb6, 0x2a, 0x16, 0x80, 0xb8, 0x10, 0x1c, 0x4a
 };
 
 const size_t sizeof_hashBlock = sizeof(hashBlock);
+const unsigned char hashBlock_witness[] = {
+
+};
+
+const size_t sizeof_hashBlock_witness = sizeof(hashBlock_witness);
 
 /* The commitment Merkle root of the above hashBlock Simplicity expression. */
 const uint32_t hashBlock_cmr[] = {

simplicity-sys/depend/simplicity/hashBlock.h

@@ -10,6 +10,8 @@
  */
 extern const unsigned char hashBlock[];
 extern const size_t sizeof_hashBlock;
+extern const unsigned char hashBlock_witness[];
+extern const size_t sizeof_hashBlock_witness;
 
 /* The commitment Merkle root of the above hashBlock Simplicity expression. */
 extern const uint32_t hashBlock_cmr[];

simplicity-sys/depend/simplicity/include/simplicity/elements/exec.h

@@ -7,13 +7,13 @@
 #include <simplicity/errorCodes.h>
 #include <simplicity/elements/env.h>
 
-/* Deserialize a Simplicity 'program' and execute it in the environment of the 'ix'th input of 'tx' with `taproot`.
+/* Deserialize a Simplicity 'program' with its 'witness' data and execute it in the environment of the 'ix'th input of 'tx' with `taproot`.
  *
  * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned,
  * meaning we were unable to determine the result of the simplicity program.
  * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value.
  *
- * If deserialization, analysis, or execution fails, then '*error' is set to some SIMPLICITY_ERR.
+ * If deserialization, analysis, or execution fails, then '*error' is set to some simplicity_err.
  *
  * If 'amr != NULL' and the annotated Merkle root of the decoded expression doesn't match 'amr' then '*error' is set to 'SIMPLICITY_ERR_AMR'.
  *
@@ -29,11 +29,13 @@
  *               unsigned char genesisBlockHash[32]
  *               NULL != amr implies unsigned char amr[32]
  *               unsigned char program[program_len]
+ *               unsigned char witness[witness_len]
  */
 extern bool elements_simplicity_execSimplicity( simplicity_err* error, unsigned char* imr
                                               , const transaction* tx, uint_fast32_t ix, const tapEnv* taproot
                                               , const unsigned char* genesisBlockHash
                                               , int64_t budget
                                               , const unsigned char* amr
-                                              , const unsigned char* program, size_t program_len);
+                                              , const unsigned char* program, size_t program_len
+                                              , const unsigned char* witness, size_t witness_len);
 #endif

simplicity-sys/depend/simplicity/include/simplicity/errorCodes.h

@@ -12,29 +12,30 @@
 typedef enum {
   SIMPLICITY_NO_ERROR = 0,
   SIMPLICITY_ERR_MALLOC = -1,
-  SIMPLICITY_ERR_BITSTREAM_EOF = -2,
   SIMPLICITY_ERR_NOT_YET_IMPLEMENTED = -3,
-  SIMPLICITY_ERR_DATA_OUT_OF_RANGE = -4,
-  SIMPLICITY_ERR_DATA_OUT_OF_ORDER = -6,
-  SIMPLICITY_ERR_FAIL_CODE = -8,
-  SIMPLICITY_ERR_STOP_CODE = -10,
-  SIMPLICITY_ERR_HIDDEN = -12,
+  SIMPLICITY_ERR_DATA_OUT_OF_RANGE = -2,
+  SIMPLICITY_ERR_DATA_OUT_OF_ORDER = -4,
+  SIMPLICITY_ERR_FAIL_CODE = -6,
+  SIMPLICITY_ERR_STOP_CODE = -8,
+  SIMPLICITY_ERR_HIDDEN = -10,
+  SIMPLICITY_ERR_BITSTREAM_EOF = -12,
   SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES = -14,
   SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING = -16,
   SIMPLICITY_ERR_TYPE_INFERENCE_UNIFICATION = -18,
   SIMPLICITY_ERR_TYPE_INFERENCE_OCCURS_CHECK = -20,
   SIMPLICITY_ERR_TYPE_INFERENCE_NOT_PROGRAM = -22,
   SIMPLICITY_ERR_WITNESS_EOF = -24,
-  SIMPLICITY_ERR_WITNESS_TRAILING_BITS = -26,
-  SIMPLICITY_ERR_UNSHARED_SUBEXPRESSION = -28,
-  SIMPLICITY_ERR_CMR = -30,
-  SIMPLICITY_ERR_AMR = -32,
+  SIMPLICITY_ERR_WITNESS_TRAILING_BYTES = -26,
+  SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING = -28,
+  SIMPLICITY_ERR_UNSHARED_SUBEXPRESSION = -30,
+  SIMPLICITY_ERR_CMR = -32,
   SIMPLICITY_ERR_EXEC_BUDGET = -34,
   SIMPLICITY_ERR_EXEC_MEMORY = -36,
   SIMPLICITY_ERR_EXEC_JET = -38,
   SIMPLICITY_ERR_EXEC_ASSERT = -40,
   SIMPLICITY_ERR_ANTIDOS = -42,
   SIMPLICITY_ERR_HIDDEN_ROOT = -44,
+  SIMPLICITY_ERR_AMR = -46,
 } simplicity_err;
 
 /* Check if failure is permanent (or success which is always permanent). */
@@ -53,8 +54,6 @@ static inline const char * SIMPLICITY_ERR_MSG(simplicity_err err) {
     return "No error";
   case SIMPLICITY_ERR_MALLOC:
     return "Memory allocation failed";
-  case SIMPLICITY_ERR_BITSTREAM_EOF:
-    return "Unexpected end of bitstream";
   case SIMPLICITY_ERR_NOT_YET_IMPLEMENTED:
     return "Incomplete implementation (this should not occur)";
   case SIMPLICITY_ERR_DATA_OUT_OF_RANGE:
@@ -67,6 +66,8 @@ static inline const char * SIMPLICITY_ERR_MSG(simplicity_err err) {
     return "Program has STOP node";
   case SIMPLICITY_ERR_HIDDEN:
     return "Program has illegal HIDDEN child node";
+  case SIMPLICITY_ERR_BITSTREAM_EOF:
+    return "Unexpected end of bitstream";
   case SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES:
     return "Trailing bytes after final byte of program";
   case SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING:
@@ -79,14 +80,14 @@ static inline const char * SIMPLICITY_ERR_MSG(simplicity_err err) {
     return "Expression not unit to unit";
   case SIMPLICITY_ERR_WITNESS_EOF:
     return "Unexpected end of witness block";
-  case SIMPLICITY_ERR_WITNESS_TRAILING_BITS:
-    return "Trailing bits after final value of witness block";
+  case SIMPLICITY_ERR_WITNESS_TRAILING_BYTES:
+    return "Trailing bytes after final byte of witness";
+  case SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING:
+    return "Illegal padding in final byte of witness";
   case SIMPLICITY_ERR_UNSHARED_SUBEXPRESSION:
     return "Subexpression not properly shared";
   case SIMPLICITY_ERR_CMR:
     return "Program's CMR does not match";
-  case SIMPLICITY_ERR_AMR:
-    return "Program's AMR does not match";
   case SIMPLICITY_ERR_EXEC_BUDGET:
     return "Program's execution cost could exceed budget";
   case SIMPLICITY_ERR_EXEC_MEMORY:
@@ -99,6 +100,8 @@ static inline const char * SIMPLICITY_ERR_MSG(simplicity_err err) {
     return "Anti-DOS check failed";
   case SIMPLICITY_ERR_HIDDEN_ROOT:
     return "Program's root is HIDDEN";
+  case SIMPLICITY_ERR_AMR:
+    return "Program's AMR does not match";
   default:
     return "Unknown error code";
   }

simplicity-sys/depend/simplicity/primitive/elements/checkSigHashAllTx1.c

@@ -10,13 +10,18 @@
 const unsigned char elementsCheckSigHashAllTx1[] = {
   0xd3, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78, 0xce, 0x56, 0x3f, 0x89, 0xa0,
   0xed, 0x94, 0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96, 0xd6, 0x79, 0x5f, 0x9c, 0x63, 0x47, 0x07, 0x02, 0xc0, 0xe2, 0x8d,
-  0x88, 0x11, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xbc, 0x67, 0x2b, 0x1f,
-  0xc4, 0xd0, 0x76, 0xca, 0x0a, 0x7a, 0xd5, 0x14, 0x56, 0x86, 0xcb, 0x6b, 0x3c, 0xaf, 0xce, 0x31, 0xd9, 0x80, 0xe8, 0xab,
-  0xe1, 0x2d, 0xa8, 0xbf, 0xfb, 0x26, 0x46, 0x44, 0x4c, 0xaf, 0x4c, 0x90, 0x9e, 0x4d, 0xf1, 0xe3, 0x01, 0xb4, 0x1b, 0x3e,
-  0x50, 0x09, 0x12, 0x7e, 0xeb, 0x0c, 0x93, 0x0f, 0x80
+  0x88, 0x10
 };
 
 const size_t sizeof_elementsCheckSigHashAllTx1 = sizeof(elementsCheckSigHashAllTx1);
+const unsigned char elementsCheckSigHashAllTx1_witness[] = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78, 0xce, 0x56, 0x3f, 0x89, 0xa0, 0xed, 0x94,
+  0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96, 0xd6, 0x79, 0x5f, 0x9c, 0x63, 0xb3, 0x01, 0xd1, 0x57, 0xc2, 0x5b, 0x51, 0x7f,
+  0xf6, 0x4c, 0x8c, 0x88, 0x99, 0x5e, 0x99, 0x21, 0x3c, 0x9b, 0xe3, 0xc6, 0x03, 0x68, 0x36, 0x7c, 0xa0, 0x12, 0x24, 0xfd,
+  0xd6, 0x19, 0x26, 0x1f
+};
+
+const size_t sizeof_elementsCheckSigHashAllTx1_witness = sizeof(elementsCheckSigHashAllTx1_witness);
 
 /* The commitment Merkle root of the above elementsCheckSigHashAllTx1 Simplicity expression. */
 const uint32_t elementsCheckSigHashAllTx1_cmr[] = {