feat: use multi-output predicates

app_cli/src/lib.rs

@@ -513,19 +513,21 @@ pub fn craft_item(
 
     // TODO instead of 'i', use 'index' (which is the blueprint (which takes
     // values as 'dust', 'gem'))
-    for (i, pod) in pods.iter().enumerate() {
+    for (def, pod) in std::iter::zip(item_def, pods.iter()) {
+        let i = def.index.clone();
         let crafted_item = CraftedItem {
             pod: pod.clone(),
-            def: item_def[i].clone(),
+            def,
         };
-        let sufix = if pods.len() > 1 {
-            format!("_{i}")
+        let suffix = if pods.len() > 1 {
+            format!("_{}", i.name())
         } else {
             "".to_string()
         };
-        let mut file = std::fs::File::create(format! {"{}{sufix}", output.display()})?;
+        let filename = format! {"{}{suffix}", output.display()};
+        let mut file = std::fs::File::create(&filename)?;
         serde_json::to_writer(&mut file, &crafted_item)?;
-        info!("Stored crafted item mined with recipe {recipe} to {output:?}{sufix}");
+        info!("Stored crafted item mined with recipe {recipe} to {filename}");
     }
 
     Ok(())

commitlib/src/lib.rs

@@ -205,9 +205,9 @@ impl<'a> ItemBuilder<'a> {
 
         // Build ItemInBatch(item, batch)
         Ok(st_custom!(self.ctx,
-        ItemInBatch() = (
-            HashOf(item_hash, batch_hash, item_def.index.hash()),
-            DictContains(keys_dict, item_def.index.name(), item_def.item_key())
+            	ItemInBatch() = (
+              		   HashOf(item_hash, batch_hash, item_def.index.hash()),
+            		   DictContains(keys_dict, item_def.index.name(), item_def.item_key())
         ))?)
     }
 

common/src/payload.rs

@@ -52,14 +52,15 @@ impl Payload {
             .expect("vec write");
         self.proof.write_bytes(&mut buffer);
         write_elems(&mut buffer, &self.created_items_root.0);
-        // TODO: What are the constraints on these lengths apart from the type casts below?
+
         assert!(self.items.len() < 256);
         buffer
             .write_all(&(self.items.len() as u8).to_le_bytes())
             .expect("vec write");
         for item in &self.items {
             write_elems(&mut buffer, &item.0);
         }
+
         assert!(self.nullifiers.len() < 256);
         buffer
             .write_all(&(self.nullifiers.len() as u8).to_le_bytes())

craftlib/src/item.rs

@@ -120,11 +120,7 @@ impl<'a> CraftBuilder<'a> {
         let mut s1 = empty_set.clone();
         s1.insert(&wood).unwrap();
         let mut inputs = s1.clone();
-        println!("1");
-        println!("{wood}");
-        println!("{stone}");
         inputs.insert(&stone).unwrap();
-        println!("2");
         Ok(st_custom!(self.ctx,
             AxeInputs() = (
                 SetInsert(s1, empty_set, wood),
@@ -218,7 +214,6 @@ impl<'a> CraftBuilder<'a> {
         let batch_hash = batch_def.batch_hash(self.params)?;
         let dust_hash = hash_values(&[batch_hash.into(), DUST_BLUEPRINT.into()]);
         let gem_hash = hash_values(&[batch_hash.into(), GEM_BLUEPRINT.into()]);
-        dbg!(&batch_def.ingredients.keys);
         let dust_key = batch_def.ingredients.keys[&DUST_BLUEPRINT.into()].clone();
         let gem_key = batch_def.ingredients.keys[&GEM_BLUEPRINT.into()].clone();
 
@@ -255,6 +250,49 @@ impl<'a> CraftBuilder<'a> {
             st_stone_disassemble_outputs
         ))?)
     }
+    pub fn st_is_dust(
+        &mut self,
+        item_def: ItemDef,
+        st_stone_disassemble: Statement,
+    ) -> anyhow::Result<Statement> {
+        let batch_hash = item_def.batch.batch_hash(self.params)?;
+        let dust_hash = hash_values(&[batch_hash.into(), DUST_BLUEPRINT.into()]);
+        let keys_dict = Dictionary::new(
+            self.params.max_depth_mt_containers,
+            item_def.batch.ingredients.keys.clone(),
+        )?;
+        let dust_key = item_def.batch.ingredients.keys[&DUST_BLUEPRINT.into()].clone();
+        Ok(st_custom!(self.ctx,
+           IsDust() = (
+               HashOf(dust_hash, batch_hash, DUST_BLUEPRINT),
+               DictContains(keys_dict, DUST_BLUEPRINT, dust_key),
+               Equal(item_def.batch.work, EMPTY_VALUE),
+               st_stone_disassemble
+           ))?)
+    }
+
+    pub fn st_is_gem(
+        &mut self,
+        item_def: ItemDef,
+        st_stone_disassemble: Statement,
+    ) -> anyhow::Result<Statement> {
+        let batch_hash = item_def.batch.batch_hash(self.params)?;
+        let gem_hash = hash_values(&[batch_hash.into(), GEM_BLUEPRINT.into()]);
+        let keys_dict = Dictionary::new(
+            self.params.max_depth_mt_containers,
+            item_def.batch.ingredients.keys.clone(),
+        )?;
+        let gem_key = item_def.batch.ingredients.keys[&GEM_BLUEPRINT.into()].clone();
+
+        Ok(st_custom!(self.ctx,
+            IsGem() = (
+                HashOf(gem_hash, batch_hash, GEM_BLUEPRINT),
+                DictContains(keys_dict, GEM_BLUEPRINT, gem_key),
+                Equal(item_def.batch.work, EMPTY_VALUE),
+                st_stone_disassemble
+            ))?)
+    }
+
     pub fn st_stone_disassemble(
         &mut self,
         st_stone_disassemble_inputs_outputs: Statement,

shell.nix

@@ -8,7 +8,7 @@ let
     wayland
     wayland.dev
     wayland-protocols
-    sway
+    emacs
     mesa
     mesa-gl-headers
     egl-wayland

synchronizer/src/main.rs

@@ -380,7 +380,7 @@ impl Node {
                         info!("Valid do_blob at slot {}, blob_index {}!", slot, blob.index);
                     }
                     Err(e) => {
-                        error!("Ignoring blob due: Invalid do_blob: {:?}", e);
+                        info!("Ignoring blob due to invalid do_blob: {:?}", e);
                         continue;
                     }
                 };