@aztec/bb.js 0.0.1-commit.d3ec352c → 0.0.1-commit.f295ac2

package/dest/node/cbind/rust_codegen.js

@@ -0,0 +1,416 @@
+/**
+ * Rust Code Generator - String template based
+ *
+ * Philosophy:
+ *   - String templates for file structure
+ *   - Simple type mapping
+ *   - Idiomatic Rust conventions
+ *   - No complex abstraction
+ */
+import { toSnakeCase, toPascalCase } from './naming.js';
+export class RustCodegen {
+    // Type mapping: Schema type -> Rust type
+    mapType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.primitive) {
+                    case 'bool': return 'bool';
+                    case 'u8': return 'u8';
+                    case 'u16': return 'u16';
+                    case 'u32': return 'u32';
+                    case 'u64': return 'u64';
+                    case 'f64': return 'f64';
+                    case 'string': return 'String';
+                    case 'bytes': return 'Vec<u8>';
+                    case 'field2': return '[Vec<u8>; 2]'; // Extension field (Fq2) - pair of 32-byte field elements
+                }
+                break;
+            case 'vector':
+                return `Vec<${this.mapType(type.element)}>`;
+            case 'array':
+                const elemType = this.mapType(type.element);
+                // Large arrays become Vec for ergonomics
+                return type.size > 32 ? `Vec<${elemType}>` : `[${elemType}; ${type.size}]`;
+            case 'optional':
+                return `Option<${this.mapType(type.element)}>`;
+            case 'struct':
+                // Convert struct names to PascalCase for Rust conventions
+                return toPascalCase(type.struct.name);
+        }
+        return 'Unknown';
+    }
+    // Check if field needs serde(with = "serde_bytes")
+    needsSerdeBytes(type) {
+        return type.kind === 'primitive' && type.primitive === 'bytes';
+    }
+    // Check if field needs serde(with = "serde_vec_bytes")
+    needsSerdeVecBytes(type) {
+        return type.kind === 'vector' && this.needsSerdeBytes(type.element);
+    }
+    // Generate struct field
+    generateField(field) {
+        const rustName = toSnakeCase(field.name);
+        const rustType = this.mapType(field.type);
+        let attrs = '';
+        // Add serde rename if needed
+        if (field.name !== rustName) {
+            attrs += `    #[serde(rename = "${field.name}")]\n`;
+        }
+        // Add serde bytes handling
+        if (this.needsSerdeVecBytes(field.type)) {
+            attrs += `    #[serde(with = "serde_vec_bytes")]\n`;
+        }
+        else if (this.needsSerdeBytes(field.type)) {
+            attrs += `    #[serde(with = "serde_bytes")]\n`;
+        }
+        return `${attrs}    pub ${rustName}: ${rustType},`;
+    }
+    // Generate a struct definition
+    generateStruct(struct, isCommand) {
+        const rustName = toPascalCase(struct.name);
+        const fields = struct.fields.map(f => this.generateField(f)).join('\n');
+        // Add serde rename if struct name changed
+        const serdeRename = struct.name !== rustName
+            ? `\n#[serde(rename = "${struct.name}")]`
+            : '';
+        // Commands need __typename field for struct identification, but skip it during serialization
+        const typenameField = isCommand
+            ? `    #[serde(rename = "__typename", skip_serializing)]\n    pub type_name: String,\n`
+            : '';
+        // Generate constructor for commands
+        const constructor = isCommand ? this.generateConstructor(struct, rustName) : '';
+        return `/// ${struct.name}
+#[derive(Debug, Clone, Serialize, Deserialize)]${serdeRename}
+pub struct ${rustName} {
+${typenameField}${fields}
+}${constructor}`;
+    }
+    // Generate constructor for command structs
+    generateConstructor(struct, rustName) {
+        const params = struct.fields.map(f => `${toSnakeCase(f.name)}: ${this.mapType(f.type)}`).join(', ');
+        const fieldInits = [
+            `            type_name: "${struct.name}".to_string(),`,
+            ...struct.fields.map(f => `            ${toSnakeCase(f.name)},`),
+        ].join('\n');
+        return `
+
+impl ${rustName} {
+    pub fn new(${params}) -> Self {
+        Self {
+${fieldInits}
+        }
+    }
+}`;
+    }
+    // Generate Command enum
+    generateCommandEnum(schema) {
+        const names = Array.from(schema.structs.keys());
+        const variants = names
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `    ${rustName}(${rustName}),`;
+        })
+            .join('\n');
+        const serializeCases = names
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `            Command::${rustName}(data) => {
+                tuple.serialize_element("${name}")?;
+                tuple.serialize_element(data)?;
+            }`;
+        })
+            .join('\n');
+        const deserializeCases = names
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `                    "${name}" => {
+                        let data = seq.next_element()?
+                            .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+                        Ok(Command::${rustName}(data))
+                    }`;
+        })
+            .join('\n');
+        const variantNames = names
+            .map(name => `"${name}"`)
+            .join(', ');
+        return `/// Command enum - wraps all possible commands
+#[derive(Debug, Clone)]
+pub enum Command {
+${variants}
+}
+
+impl Serialize for Command {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where S: serde::Serializer {
+        use serde::ser::SerializeTuple;
+        let mut tuple = serializer.serialize_tuple(2)?;
+        match self {
+${serializeCases}
+        }
+        tuple.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for Command {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: serde::Deserializer<'de> {
+        use serde::de::{SeqAccess, Visitor};
+        struct CommandVisitor;
+
+        impl<'de> Visitor<'de> for CommandVisitor {
+            type Value = Command;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a 2-element array [name, payload]")
+            }
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where A: SeqAccess<'de> {
+                let name: String = seq.next_element()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                match name.as_str() {
+${deserializeCases}
+                    _ => Err(serde::de::Error::unknown_variant(&name, &[${variantNames}])),
+                }
+            }
+        }
+        deserializer.deserialize_tuple(2, CommandVisitor)
+    }
+}`;
+    }
+    // Generate Response enum
+    generateResponseEnum(schema) {
+        // Include all response types from commands plus ErrorResponse if it exists
+        const commandResponseTypes = Array.from(new Set(schema.commands.map(c => c.responseType)));
+        const responseTypes = schema.responses.has('ErrorResponse')
+            ? [...commandResponseTypes, 'ErrorResponse']
+            : commandResponseTypes;
+        const variants = responseTypes
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `    ${rustName}(${rustName}),`;
+        })
+            .join('\n');
+        const serializeCases = responseTypes
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `            Response::${rustName}(data) => {
+                tuple.serialize_element("${name}")?;
+                tuple.serialize_element(data)?;
+            }`;
+        })
+            .join('\n');
+        const deserializeCases = responseTypes
+            .map(name => {
+            const rustName = toPascalCase(name);
+            return `                    "${name}" => {
+                        let data = seq.next_element()?
+                            .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+                        Ok(Response::${rustName}(data))
+                    }`;
+        })
+            .join('\n');
+        const variantNames = responseTypes.map(name => `"${name}"`).join(', ');
+        return `/// Response enum - wraps all possible responses
+#[derive(Debug, Clone)]
+pub enum Response {
+${variants}
+}
+
+impl Serialize for Response {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where S: serde::Serializer {
+        use serde::ser::SerializeTuple;
+        let mut tuple = serializer.serialize_tuple(2)?;
+        match self {
+${serializeCases}
+        }
+        tuple.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for Response {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: serde::Deserializer<'de> {
+        use serde::de::{SeqAccess, Visitor};
+        struct ResponseVisitor;
+
+        impl<'de> Visitor<'de> for ResponseVisitor {
+            type Value = Response;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a 2-element array [name, payload]")
+            }
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where A: SeqAccess<'de> {
+                let name: String = seq.next_element()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                match name.as_str() {
+${deserializeCases}
+                    _ => Err(serde::de::Error::unknown_variant(&name, &[${variantNames}])),
+                }
+            }
+        }
+        deserializer.deserialize_tuple(2, ResponseVisitor)
+    }
+}`;
+    }
+    // Generate serde helper modules
+    generateSerdeHelpers() {
+        return `mod serde_bytes {
+    use serde::{Deserialize, Deserializer, Serializer};
+    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
+    where S: Serializer { serializer.serialize_bytes(bytes) }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+    where D: Deserializer<'de> { <Vec<u8>>::deserialize(deserializer) }
+}
+
+mod serde_vec_bytes {
+    use serde::{Deserialize, Deserializer, Serializer, Serialize};
+    use serde::ser::SerializeSeq;
+    use serde::de::{SeqAccess, Visitor};
+
+    #[derive(Serialize, Deserialize)]
+    struct BytesWrapper(#[serde(with = "super::serde_bytes")] Vec<u8>);
+
+    pub fn serialize<S>(vec: &Vec<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
+    where S: Serializer {
+        let mut seq = serializer.serialize_seq(Some(vec.len()))?;
+        for bytes in vec {
+            seq.serialize_element(&BytesWrapper(bytes.clone()))?;
+        }
+        seq.end()
+    }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Vec<u8>>, D::Error>
+    where D: Deserializer<'de> {
+        struct VecVecU8Visitor;
+        impl<'de> Visitor<'de> for VecVecU8Visitor {
+            type Value = Vec<Vec<u8>>;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a sequence of byte arrays")
+            }
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where A: SeqAccess<'de> {
+                let mut vec = Vec::new();
+                while let Some(wrapper) = seq.next_element::<BytesWrapper>()? {
+                    vec.push(wrapper.0);
+                }
+                Ok(vec)
+            }
+        }
+        deserializer.deserialize_seq(VecVecU8Visitor)
+    }
+}`;
+    }
+    // Generate types file
+    generateTypes(schema) {
+        // Create set of top-level command struct names (only these need __typename)
+        const commandNames = new Set(schema.commands.map(c => c.name));
+        // Generate all structs (commands first, then responses)
+        const commandStructs = Array.from(schema.structs.values())
+            .map(s => this.generateStruct(s, commandNames.has(s.name)))
+            .join('\n\n');
+        const responseStructs = Array.from(schema.responses.values())
+            .map(s => this.generateStruct(s, false))
+            .join('\n\n');
+        return `//! AUTOGENERATED - DO NOT EDIT
+//! Generated from Barretenberg msgpack schema
+
+use serde::{Deserialize, Serialize};
+
+${this.generateSerdeHelpers()}
+
+${commandStructs}
+
+${responseStructs}
+
+${this.generateCommandEnum(schema)}
+
+${this.generateResponseEnum(schema)}
+`;
+    }
+    // Generate API method
+    generateApiMethod(command) {
+        const methodName = toSnakeCase(command.name);
+        const cmdRustName = toPascalCase(command.name);
+        const respRustName = toPascalCase(command.responseType);
+        const params = command.fields.map(f => {
+            const rustType = this.mapType(f.type);
+            // Only convert simple Vec<u8> to &[u8], not nested types
+            const apiType = rustType === 'Vec<u8>' ? '&[u8]' : rustType;
+            return `${toSnakeCase(f.name)}: ${apiType}`;
+        }).join(', ');
+        const paramConversions = command.fields.map(f => {
+            const name = toSnakeCase(f.name);
+            const rustType = this.mapType(f.type);
+            // Only convert slices back to Vec
+            if (rustType === 'Vec<u8>') {
+                return `${name}.to_vec()`;
+            }
+            return name;
+        }).join(', ');
+        return `    /// Execute ${command.name} command
+    pub fn ${methodName}(&mut self, ${params}) -> Result<${respRustName}> {
+        let cmd = Command::${cmdRustName}(${cmdRustName}::new(${paramConversions}));
+        match self.execute(cmd)? {
+            Response::${respRustName}(resp) => Ok(resp),
+            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
+                err.message
+            )),
+            _ => Err(BarretenbergError::InvalidResponse(
+                "Expected ${command.responseType}".to_string()
+            )),
+        }
+    }`;
+    }
+    // Generate API file
+    generateApi(schema) {
+        const apiMethods = schema.commands
+            .filter(c => c.name !== 'Shutdown')
+            .map(c => this.generateApiMethod(c))
+            .join('\n\n');
+        return `//! AUTOGENERATED - DO NOT EDIT
+//! High-level Barretenberg API - msgpack details hidden
+
+use crate::backend::Backend;
+use crate::error::{BarretenbergError, Result};
+use crate::generated_types::*;
+
+/// High-level Barretenberg API
+pub struct BarretenbergApi<B: Backend> {
+    backend: B,
+}
+
+impl<B: Backend> BarretenbergApi<B> {
+    /// Create API with custom backend
+    pub fn new(backend: B) -> Self {
+        Self { backend }
+    }
+
+    fn execute(&mut self, command: Command) -> Result<Response> {
+        let input_buffer = rmp_serde::to_vec_named(&vec![command])
+            .map_err(|e| BarretenbergError::Serialization(e.to_string()))?;
+
+        let output_buffer = self.backend.call(&input_buffer)?;
+
+        let response: Response = rmp_serde::from_slice(&output_buffer)
+            .map_err(|e| BarretenbergError::Deserialization(e.to_string()))?;
+
+        Ok(response)
+    }
+
+${apiMethods}
+
+    /// Shutdown backend gracefully
+    pub fn shutdown(&mut self) -> Result<()> {
+        let cmd = Command::Shutdown(Shutdown::new());
+        let _ = self.execute(cmd)?;
+        self.backend.destroy()
+    }
+
+    /// Destroy backend without shutdown command
+    pub fn destroy(&mut self) -> Result<()> {
+        self.backend.destroy()
+    }
+}
+`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust_codegen.js","sourceRoot":"","sources":["../../../src/cbind/rust_codegen.ts"],"names":[],"mappings":"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"}

package/dest/node/cbind/schema_visitor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Schema Visitor - Minimal abstraction over raw msgpack schema
+ *
+ * Philosophy:
+ *   - Keep raw schema structure
+ *   - Resolve type references into a graph
+ *   - No normalization - languages handle their own conventions
+ *   - Output is "compiled schema" with resolved types
+ */
+export type PrimitiveType = 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'f64' | 'string' | 'bytes' | 'field2';
+export interface Type {
+    kind: 'primitive' | 'vector' | 'array' | 'optional' | 'struct';
+    primitive?: PrimitiveType;
+    element?: Type;
+    size?: number;
+    struct?: Struct;
+}
+export interface Field {
+    name: string;
+    type: Type;
+}
+export interface Struct {
+    name: string;
+    fields: Field[];
+}
+export interface Command {
+    name: string;
+    fields: Field[];
+    responseType: string;
+}
+export interface CompiledSchema {
+    structs: Map<string, Struct>;
+    commands: Command[];
+    responses: Map<string, Struct>;
+}
+/**
+ * SchemaVisitor - Walks raw msgpack schema and resolves references
+ */
+export declare class SchemaVisitor {
+    private structs;
+    private responses;
+    visit(commandsSchema: any, responsesSchema: any): CompiledSchema;
+    private visitStruct;
+    private visitType;
+    private resolvePrimitive;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hX3Zpc2l0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jYmluZC9zY2hlbWFfdmlzaXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUVILE1BQU0sTUFBTSxhQUFhLEdBQUcsTUFBTSxHQUFHLElBQUksR0FBRyxLQUFLLEdBQUcsS0FBSyxHQUFHLEtBQUssR0FBRyxLQUFLLEdBQUcsUUFBUSxHQUFHLE9BQU8sR0FBRyxRQUFRLENBQUM7QUFFMUcsTUFBTSxXQUFXLElBQUk7SUFDbkIsSUFBSSxFQUFFLFdBQVcsR0FBRyxRQUFRLEdBQUcsT0FBTyxHQUFHLFVBQVUsR0FBRyxRQUFRLENBQUM7SUFDL0QsU0FBUyxDQUFDLEVBQUUsYUFBYSxDQUFDO0lBQzFCLE9BQU8sQ0FBQyxFQUFFLElBQUksQ0FBQztJQUNmLElBQUksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNkLE1BQU0sQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNqQjtBQUVELE1BQU0sV0FBVyxLQUFLO0lBQ3BCLElBQUksRUFBRSxNQUFNLENBQUM7SUFDYixJQUFJLEVBQUUsSUFBSSxDQUFDO0NBQ1o7QUFFRCxNQUFNLFdBQVcsTUFBTTtJQUNyQixJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDO0NBQ2pCO0FBRUQsTUFBTSxXQUFXLE9BQU87SUFDdEIsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQztJQUNoQixZQUFZLEVBQUUsTUFBTSxDQUFDO0NBQ3RCO0FBRUQsTUFBTSxXQUFXLGNBQWM7SUFFN0IsT0FBTyxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFHN0IsUUFBUSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBR3BCLFNBQVMsRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQ2hDO0FBRUQ7O0dBRUc7QUFDSCxxQkFBYSxhQUFhO0lBQ3hCLE9BQU8sQ0FBQyxPQUFPLENBQTZCO0lBQzVDLE9BQU8sQ0FBQyxTQUFTLENBQTZCO0lBRTlDLEtBQUssQ0FBQyxjQUFjLEVBQUUsR0FBRyxFQUFFLGVBQWUsRUFBRSxHQUFHLEdBQUcsY0FBYyxDQTJDL0Q7SUFFRCxPQUFPLENBQUMsV0FBVztJQWdCbkIsT0FBTyxDQUFDLFNBQVM7SUE2RWpCLE9BQU8sQ0FBQyxnQkFBZ0I7Q0EwQnpCIn0=

package/dest/node/cbind/schema_visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_visitor.d.ts","sourceRoot":"","sources":["../../../src/cbind/schema_visitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE1G,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC/D,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAE7B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAG7B,QAAQ,EAAE,OAAO,EAAE,CAAC;IAGpB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAA6B;IAE9C,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,GAAG,cAAc,CA2C/D;IAED,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,SAAS;IA6EjB,OAAO,CAAC,gBAAgB;CA0BzB"}

package/dest/node/cbind/schema_visitor.js

@@ -0,0 +1,158 @@
+/**
+ * Schema Visitor - Minimal abstraction over raw msgpack schema
+ *
+ * Philosophy:
+ *   - Keep raw schema structure
+ *   - Resolve type references into a graph
+ *   - No normalization - languages handle their own conventions
+ *   - Output is "compiled schema" with resolved types
+ */
+/**
+ * SchemaVisitor - Walks raw msgpack schema and resolves references
+ */
+export class SchemaVisitor {
+    structs = new Map();
+    responses = new Map();
+    visit(commandsSchema, responsesSchema) {
+        // Reset state
+        this.structs.clear();
+        this.responses.clear();
+        const commands = [];
+        // Schema format: ["named_union", [[name, schema], ...]]
+        const commandPairs = commandsSchema[1];
+        const responsePairs = responsesSchema[1];
+        // First, visit all response types (including ErrorResponse)
+        for (const [respName, respSchema] of responsePairs) {
+            if (typeof respSchema !== 'string') {
+                const respStruct = this.visitStruct(respName, respSchema);
+                this.responses.set(respName, respStruct);
+            }
+        }
+        // Visit all commands and pair with responses
+        for (let i = 0; i < commandPairs.length; i++) {
+            const [cmdName, cmdSchema] = commandPairs[i];
+            // Find matching response (skip ErrorResponse which is always last)
+            const normalResponses = responsePairs.filter(([name]) => name !== 'ErrorResponse');
+            const [respName] = normalResponses[i];
+            // Discover command structure
+            const cmdStruct = this.visitStruct(cmdName, cmdSchema);
+            this.structs.set(cmdName, cmdStruct);
+            // Create command mapping
+            commands.push({
+                name: cmdName,
+                fields: cmdStruct.fields,
+                responseType: respName,
+            });
+        }
+        return {
+            structs: this.structs,
+            commands,
+            responses: this.responses,
+        };
+    }
+    visitStruct(name, schema) {
+        const fields = [];
+        // Schema is an object with __typename and fields
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            fields.push({
+                name: key,
+                type: this.visitType(value),
+            });
+        }
+        return { name, fields };
+    }
+    visitType(schema) {
+        // Primitive string type
+        if (typeof schema === 'string') {
+            return this.resolvePrimitive(schema);
+        }
+        // Array type descriptor: ['vector', [elementType]]
+        if (Array.isArray(schema)) {
+            const [kind, args] = schema;
+            switch (kind) {
+                case 'vector': {
+                    const [elemType] = args;
+                    // Special case: vector<unsigned char> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'vector',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'array': {
+                    const [elemType, size] = args;
+                    // Special case: array<unsigned char, N> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'array',
+                        element: this.visitType(elemType),
+                        size,
+                    };
+                }
+                case 'optional': {
+                    const [elemType] = args;
+                    return {
+                        kind: 'optional',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'shared_ptr': {
+                    // Dereference shared_ptr - just use inner type
+                    const [innerType] = args;
+                    return this.visitType(innerType);
+                }
+                case 'alias': {
+                    // Alias types (like uint256_t) are treated as bytes
+                    return { kind: 'primitive', primitive: 'bytes' };
+                }
+                default:
+                    throw new Error(`Unknown type kind: ${kind}`);
+            }
+        }
+        // Inline struct definition
+        if (typeof schema === 'object' && schema.__typename) {
+            const structName = schema.__typename;
+            // Check if already visited
+            if (!this.structs.has(structName)) {
+                const struct = this.visitStruct(structName, schema);
+                this.structs.set(structName, struct);
+            }
+            return {
+                kind: 'struct',
+                struct: this.structs.get(structName),
+            };
+        }
+        throw new Error(`Cannot resolve type: ${JSON.stringify(schema)}`);
+    }
+    resolvePrimitive(name) {
+        const primitiveMap = {
+            'bool': 'bool',
+            'int': 'u32',
+            'unsigned int': 'u32',
+            'unsigned short': 'u16',
+            'unsigned long': 'u64',
+            'unsigned char': 'u8',
+            'double': 'f64',
+            'string': 'string',
+            'bin32': 'bytes',
+            'field2': 'field2', // Extension field (Fq2) - pair of field elements
+        };
+        const primitive = primitiveMap[name];
+        if (primitive) {
+            return { kind: 'primitive', primitive };
+        }
+        // Unknown primitive - treat as struct reference
+        // This will be resolved later if it's a real struct
+        return {
+            kind: 'struct',
+            struct: { name, fields: [] }, // Placeholder
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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