fix(bindgen): port to spend-groups/leaves ABI; gate whole workspace in CI

Rewrite the IR and TS/Go emitters around AbiFunctionGroup{arkade, leaves[]}
instead of the removed serverVariant/witnessSchema shape; regenerate fixtures
from the compiler; per-leaf witness types and buildWitness(group, leaf, w).
CI now builds/clippies/tests --workspace so sub-crates can't silently break.

Author: msinkec

.github/workflows/build.yml

@@ -19,11 +19,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Build
-        run: cargo build --verbose
+        run: cargo build --workspace --verbose
       - name: Clippy
-        run: cargo clippy --all-targets -- -D warnings
+        run: cargo clippy --workspace --all-targets -- -D warnings
       - name: Run tests
-        run: cargo test --verbose
+        run: cargo test --workspace --verbose
 
   check-format:
 

arkade-bindgen/src/ir.rs

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use arkade_compiler::ContractJson;
 
 /// Wire-encoding descriptor, matching the compiler's `WitnessElement.encoding` field.
@@ -41,8 +39,8 @@ impl Encoding {
         }
     }
 
-    /// Infer encoding from an Arkade Script type string.
-    /// Used as fallback when `witnessSchema` is absent.
+    /// Infer encoding from an Arkade Script type string. Constructor parameters
+    /// and covenant inputs carry only a type, not an explicit encoding.
     pub fn from_ark_type(type_str: &str) -> Self {
         match type_str {
             "pubkey" => Encoding::Compressed33,
@@ -72,7 +70,7 @@ impl Encoding {
     }
 }
 
-/// A typed field in the IR (constructor param or witness element).
+/// A typed field in the IR (constructor param, covenant input, or witness element).
 #[derive(Debug, Clone)]
 pub struct Field {
     /// Field name as it appears in the artifact (camelCase).
@@ -81,34 +79,49 @@ pub struct Field {
     pub ark_type: String,
     /// Wire encoding descriptor.
     pub encoding: Encoding,
-    /// True if this field is injected by the Arkade server (e.g., "serverSig").
-    pub is_server_injected: bool,
+    /// True when Arkade infrastructure supplies this field (e.g., co-signer sigs).
+    pub is_injected: bool,
 }
 
-/// One variant of a function (cooperative or exit).
+/// One L1 tapleaf spend path within a group.
 #[derive(Debug, Clone)]
-pub struct VariantIR {
-    /// Fields the caller must supply (excludes server-injected).
-    pub user_fields: Vec<Field>,
-    /// All fields including server-injected.
-    pub all_fields: Vec<Field>,
-    /// Raw assembly instructions.
+pub struct LeafIR {
+    /// Leaf name (source tapscript name, or covenant name for a synthesized default).
+    pub name: String,
+    /// Witness stack the caller supplies, in order. Injected fields are marked.
+    pub witness_fields: Vec<Field>,
+    /// Tapleaf assembly.
     pub asm: Vec<String>,
-    /// Human-readable requirement descriptions for doc comments.
-    pub requirements: Vec<String>,
-    /// Whether this is an N-of-N multisig fallback exit path.
-    pub is_nofn_fallback: bool,
 }
 
-/// A paired function with cooperative and exit variants.
+impl LeafIR {
+    /// Fields the caller must supply (excludes infrastructure-injected ones).
+    pub fn user_fields(&self) -> Vec<&Field> {
+        self.witness_fields
+            .iter()
+            .filter(|f| !f.is_injected)
+            .collect()
+    }
+}
+
+/// The emulator-run covenant attached to a function-backed group.
 #[derive(Debug, Clone)]
-pub struct FunctionIR {
-    /// Function name as it appears in the artifact.
+pub struct CovenantIR {
+    /// Covenant inputs (function parameters, array-expanded).
+    pub inputs: Vec<Field>,
+    /// Covenant assembly.
+    pub asm: Vec<String>,
+}
+
+/// A spend group: an optional covenant plus its L1 leaves.
+#[derive(Debug, Clone)]
+pub struct GroupIR {
+    /// Group name (covenant function name, or a standalone leaf's own name).
     pub name: String,
-    /// Cooperative path (serverVariant: true).
-    pub cooperative: VariantIR,
-    /// Exit path (serverVariant: false).
-    pub exit: VariantIR,
+    /// Emulator covenant; absent for groups of standalone leaves.
+    pub covenant: Option<CovenantIR>,
+    /// L1 tapleaves grouped under this entry.
+    pub leaves: Vec<LeafIR>,
 }
 
 /// The complete intermediate representation of a contract.
@@ -118,164 +131,70 @@ pub struct ContractIR {
     pub name: String,
     /// Typed constructor parameters.
     pub constructor_fields: Vec<Field>,
-    /// Paired functions (cooperative + exit).
-    pub functions: Vec<FunctionIR>,
+    /// Spend groups in artifact order.
+    pub groups: Vec<GroupIR>,
     /// Original .ark source code, if embedded.
     pub source: Option<String>,
     /// Compiler version string.
     pub compiler_version: Option<String>,
 }
 
+fn field_from_ark_type(name: &str, ark_type: &str) -> Field {
+    Field {
+        name: name.to_string(),
+        ark_type: ark_type.to_string(),
+        encoding: Encoding::from_ark_type(ark_type),
+        is_injected: false,
+    }
+}
+
 /// Build an IR from a compiled contract artifact.
 pub fn build_ir(artifact: &ContractJson) -> Result<ContractIR, String> {
     let constructor_fields = artifact
         .parameters
         .iter()
-        .map(|p| Field {
-            name: p.name.clone(),
-            ark_type: p.param_type.clone(),
-            encoding: Encoding::from_ark_type(&p.param_type),
-            is_server_injected: false,
-        })
+        .map(|p| field_from_ark_type(&p.name, &p.param_type))
         .collect();
 
-    let functions = pair_functions(artifact)?;
+    let groups = artifact
+        .functions
+        .iter()
+        .map(|group| GroupIR {
+            name: group.name.clone(),
+            covenant: group.arkade.as_ref().map(|cov| CovenantIR {
+                inputs: cov
+                    .inputs
+                    .iter()
+                    .map(|i| field_from_ark_type(&i.name, &i.param_type))
+                    .collect(),
+                asm: cov.asm.clone(),
+            }),
+            leaves: group
+                .leaves
+                .iter()
+                .map(|leaf| LeafIR {
+                    name: leaf.name.clone(),
+                    witness_fields: leaf
+                        .witness
+                        .iter()
+                        .map(|w| Field {
+                            name: w.name.clone(),
+                            ark_type: w.elem_type.clone(),
+                            encoding: Encoding::parse(&w.encoding),
+                            is_injected: w.injected,
+                        })
+                        .collect(),
+                    asm: leaf.asm.clone(),
+                })
+                .collect(),
+        })
+        .collect();
 
     Ok(ContractIR {
         name: artifact.name.clone(),
         constructor_fields,
-        functions,
+        groups,
         source: artifact.source.clone(),
         compiler_version: artifact.compiler.as_ref().map(|c| c.version.clone()),
     })
 }
-
-/// Group artifact functions by name and pair cooperative + exit variants.
-fn pair_functions(artifact: &ContractJson) -> Result<Vec<FunctionIR>, String> {
-    // Use BTreeMap to preserve insertion order (sorted, but stable).
-    // We'll re-sort by first-appearance order afterwards.
-    let mut groups: BTreeMap<String, (Option<usize>, Vec<&arkade_compiler::models::AbiFunction>)> =
-        BTreeMap::new();
-
-    for (idx, func) in artifact.functions.iter().enumerate() {
-        let entry = groups
-            .entry(func.name.clone())
-            .or_insert_with(|| (Some(idx), Vec::new()));
-        entry.1.push(func);
-    }
-
-    // Sort by first appearance order
-    let mut ordered: Vec<_> = groups.into_iter().collect();
-    ordered.sort_by_key(|(_, (first_idx, _))| first_idx.unwrap_or(usize::MAX));
-
-    let mut result = Vec::new();
-
-    for (name, (_, variants)) in ordered {
-        let mut cooperative = None;
-        let mut exit = None;
-
-        for func in &variants {
-            if func.server_variant {
-                if cooperative.is_some() {
-                    return Err(format!(
-                        "Function '{}' has multiple cooperative variants",
-                        name
-                    ));
-                }
-                cooperative = Some(*func);
-            } else {
-                if exit.is_some() {
-                    return Err(format!("Function '{}' has multiple exit variants", name));
-                }
-                exit = Some(*func);
-            }
-        }
-
-        let cooperative_func = cooperative
-            .ok_or_else(|| format!("Function '{}' missing cooperative variant", name))?;
-        let exit_func = exit.ok_or_else(|| format!("Function '{}' missing exit variant", name))?;
-
-        result.push(FunctionIR {
-            name: name.clone(),
-            cooperative: build_variant(cooperative_func),
-            exit: build_variant(exit_func),
-        });
-    }
-
-    Ok(result)
-}
-
-/// Build a VariantIR from a single AbiFunction.
-fn build_variant(func: &arkade_compiler::models::AbiFunction) -> VariantIR {
-    let has_witness_schema = !func.witness_schema.is_empty();
-
-    // Check if "serverSig" is a user-declared input (not protocol-injected)
-    let user_declared_server_sig = func.function_inputs.iter().any(|fi| fi.name == "serverSig");
-
-    let all_fields: Vec<Field> = if has_witness_schema {
-        // Primary path: use witnessSchema with explicit encodings
-        func.witness_schema
-            .iter()
-            .map(|w| Field {
-                name: w.name.clone(),
-                ark_type: w.elem_type.clone(),
-                encoding: Encoding::parse(&w.encoding),
-                is_server_injected: func.server_variant
-                    && w.name == "serverSig"
-                    && !user_declared_server_sig,
-            })
-            .collect()
-    } else {
-        // Fallback: infer encodings from functionInputs type strings
-        let mut fields: Vec<Field> = func
-            .function_inputs
-            .iter()
-            .map(|fi| Field {
-                name: fi.name.clone(),
-                ark_type: fi.param_type.clone(),
-                encoding: Encoding::from_ark_type(&fi.param_type),
-                is_server_injected: false,
-            })
-            .collect();
-
-        // If this is a cooperative variant and serverSig isn't user-declared, add it
-        if func.server_variant && !user_declared_server_sig {
-            fields.push(Field {
-                name: "serverSig".to_string(),
-                ark_type: "signature".to_string(),
-                encoding: Encoding::Schnorr64,
-                is_server_injected: true,
-            });
-        }
-
-        fields
-    };
-
-    let user_fields = all_fields
-        .iter()
-        .filter(|f| !f.is_server_injected)
-        .cloned()
-        .collect();
-
-    let requirements = func
-        .require
-        .iter()
-        .map(|r| {
-            if let Some(ref msg) = r.message {
-                format!("{}: {}", r.req_type, msg)
-            } else {
-                r.req_type.clone()
-            }
-        })
-        .collect();
-
-    let is_nofn_fallback = func.require.iter().any(|r| r.req_type == "nOfNMultisig");
-
-    VariantIR {
-        user_fields,
-        all_fields,
-        asm: func.asm.clone(),
-        requirements,
-        is_nofn_fallback,
-    }
-}

arkade-bindgen/src/lib.rs

@@ -16,6 +16,7 @@ pub enum Target {
 }
 
 impl Target {
+    #[allow(clippy::should_implement_trait)]
     pub fn from_str(s: &str) -> Option<Self> {
         match s {
             "typescript" | "ts" => Some(Target::TypeScript),

arkade-bindgen/src/main.rs

@@ -151,7 +151,7 @@ fn collect_artifacts(input: &Path) -> Vec<PathBuf> {
             .filter_map(|entry| {
                 let entry = entry.ok()?;
                 let path = entry.path();
-                if path.extension().map_or(false, |ext| ext == "json") {
+                if path.extension().is_some_and(|ext| ext == "json") {
                     Some(path)
                 } else {
                     None

arkade-bindgen/src/naming.rs

@@ -91,7 +91,7 @@ fn split_words(s: &str) -> Vec<String> {
             let prev_is_upper = current
                 .chars()
                 .last()
-                .map_or(false, |c| c.is_ascii_uppercase());
+                .is_some_and(|c| c.is_ascii_uppercase());
             if prev_is_upper {
                 // Continue the caps run
                 current.push(ch);