barretenberg-rs 4.0.0-devnet.3-patch.3

//! 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)
    }

    /// Execute CircuitProve command
    pub fn circuit_prove(&mut self, circuit: CircuitInput, witness: &[u8], settings: ProofSystemSettings) -> Result<CircuitProveResponse> {
        let cmd = Command::CircuitProve(CircuitProve::new(circuit, witness.to_vec(), settings));
        match self.execute(cmd)? {
            Response::CircuitProveResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected CircuitProveResponse".to_string()
            )),
        }
    }

    /// Execute CircuitComputeVk command
    pub fn circuit_compute_vk(&mut self, circuit: CircuitInputNoVK, settings: ProofSystemSettings) -> Result<CircuitComputeVkResponse> {
        let cmd = Command::CircuitComputeVk(CircuitComputeVk::new(circuit, settings));
        match self.execute(cmd)? {
            Response::CircuitComputeVkResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected CircuitComputeVkResponse".to_string()
            )),
        }
    }

    /// Execute CircuitStats command
    pub fn circuit_stats(&mut self, circuit: CircuitInput, include_gates_per_opcode: bool, settings: ProofSystemSettings) -> Result<CircuitInfoResponse> {
        let cmd = Command::CircuitStats(CircuitStats::new(circuit, include_gates_per_opcode, settings));
        match self.execute(cmd)? {
            Response::CircuitInfoResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected CircuitInfoResponse".to_string()
            )),
        }
    }

    /// Execute CircuitVerify command
    pub fn circuit_verify(&mut self, verification_key: &[u8], public_inputs: Vec<Vec<u8>>, proof: Vec<Vec<u8>>, settings: ProofSystemSettings) -> Result<CircuitVerifyResponse> {
        let cmd = Command::CircuitVerify(CircuitVerify::new(verification_key.to_vec(), public_inputs, proof, settings));
        match self.execute(cmd)? {
            Response::CircuitVerifyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected CircuitVerifyResponse".to_string()
            )),
        }
    }

    /// Execute ChonkComputeVk command
    pub fn chonk_compute_vk(&mut self, circuit: CircuitInputNoVK) -> Result<ChonkComputeVkResponse> {
        let cmd = Command::ChonkComputeVk(ChonkComputeVk::new(circuit));
        match self.execute(cmd)? {
            Response::ChonkComputeVkResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkComputeVkResponse".to_string()
            )),
        }
    }

    /// Execute ChonkStart command
    pub fn chonk_start(&mut self, num_circuits: u64) -> Result<ChonkStartResponse> {
        let cmd = Command::ChonkStart(ChonkStart::new(num_circuits));
        match self.execute(cmd)? {
            Response::ChonkStartResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkStartResponse".to_string()
            )),
        }
    }

    /// Execute ChonkLoad command
    pub fn chonk_load(&mut self, circuit: CircuitInput) -> Result<ChonkLoadResponse> {
        let cmd = Command::ChonkLoad(ChonkLoad::new(circuit));
        match self.execute(cmd)? {
            Response::ChonkLoadResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkLoadResponse".to_string()
            )),
        }
    }

    /// Execute ChonkAccumulate command
    pub fn chonk_accumulate(&mut self, witness: &[u8]) -> Result<ChonkAccumulateResponse> {
        let cmd = Command::ChonkAccumulate(ChonkAccumulate::new(witness.to_vec()));
        match self.execute(cmd)? {
            Response::ChonkAccumulateResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkAccumulateResponse".to_string()
            )),
        }
    }

    /// Execute ChonkProve command
    pub fn chonk_prove(&mut self, ) -> Result<ChonkProveResponse> {
        let cmd = Command::ChonkProve(ChonkProve::new());
        match self.execute(cmd)? {
            Response::ChonkProveResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkProveResponse".to_string()
            )),
        }
    }

    /// Execute ChonkVerify command
    pub fn chonk_verify(&mut self, proof: ChonkProof, vk: &[u8]) -> Result<ChonkVerifyResponse> {
        let cmd = Command::ChonkVerify(ChonkVerify::new(proof, vk.to_vec()));
        match self.execute(cmd)? {
            Response::ChonkVerifyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkVerifyResponse".to_string()
            )),
        }
    }

    /// Execute VkAsFields command
    pub fn vk_as_fields(&mut self, verification_key: &[u8]) -> Result<VkAsFieldsResponse> {
        let cmd = Command::VkAsFields(VkAsFields::new(verification_key.to_vec()));
        match self.execute(cmd)? {
            Response::VkAsFieldsResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected VkAsFieldsResponse".to_string()
            )),
        }
    }

    /// Execute MegaVkAsFields command
    pub fn mega_vk_as_fields(&mut self, verification_key: &[u8]) -> Result<MegaVkAsFieldsResponse> {
        let cmd = Command::MegaVkAsFields(MegaVkAsFields::new(verification_key.to_vec()));
        match self.execute(cmd)? {
            Response::MegaVkAsFieldsResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected MegaVkAsFieldsResponse".to_string()
            )),
        }
    }

    /// Execute CircuitWriteSolidityVerifier command
    pub fn circuit_write_solidity_verifier(&mut self, verification_key: &[u8], settings: ProofSystemSettings) -> Result<CircuitWriteSolidityVerifierResponse> {
        let cmd = Command::CircuitWriteSolidityVerifier(CircuitWriteSolidityVerifier::new(verification_key.to_vec(), settings));
        match self.execute(cmd)? {
            Response::CircuitWriteSolidityVerifierResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected CircuitWriteSolidityVerifierResponse".to_string()
            )),
        }
    }

    /// Execute ChonkCheckPrecomputedVk command
    pub fn chonk_check_precomputed_vk(&mut self, circuit: CircuitInput) -> Result<ChonkCheckPrecomputedVkResponse> {
        let cmd = Command::ChonkCheckPrecomputedVk(ChonkCheckPrecomputedVk::new(circuit));
        match self.execute(cmd)? {
            Response::ChonkCheckPrecomputedVkResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkCheckPrecomputedVkResponse".to_string()
            )),
        }
    }

    /// Execute ChonkStats command
    pub fn chonk_stats(&mut self, circuit: CircuitInputNoVK, include_gates_per_opcode: bool) -> Result<ChonkStatsResponse> {
        let cmd = Command::ChonkStats(ChonkStats::new(circuit, include_gates_per_opcode));
        match self.execute(cmd)? {
            Response::ChonkStatsResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkStatsResponse".to_string()
            )),
        }
    }

    /// Execute ChonkCompressProof command
    pub fn chonk_compress_proof(&mut self, proof: ChonkProof) -> Result<ChonkCompressProofResponse> {
        let cmd = Command::ChonkCompressProof(ChonkCompressProof::new(proof));
        match self.execute(cmd)? {
            Response::ChonkCompressProofResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkCompressProofResponse".to_string()
            )),
        }
    }

    /// Execute ChonkDecompressProof command
    pub fn chonk_decompress_proof(&mut self, compressed_proof: &[u8]) -> Result<ChonkDecompressProofResponse> {
        let cmd = Command::ChonkDecompressProof(ChonkDecompressProof::new(compressed_proof.to_vec()));
        match self.execute(cmd)? {
            Response::ChonkDecompressProofResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected ChonkDecompressProofResponse".to_string()
            )),
        }
    }

    /// Execute Poseidon2Hash command
    pub fn poseidon2_hash(&mut self, inputs: Vec<Vec<u8>>) -> Result<Poseidon2HashResponse> {
        let cmd = Command::Poseidon2Hash(Poseidon2Hash::new(inputs));
        match self.execute(cmd)? {
            Response::Poseidon2HashResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Poseidon2HashResponse".to_string()
            )),
        }
    }

    /// Execute Poseidon2Permutation command
    pub fn poseidon2_permutation(&mut self, inputs: [Vec<u8>; 4]) -> Result<Poseidon2PermutationResponse> {
        let cmd = Command::Poseidon2Permutation(Poseidon2Permutation::new(inputs));
        match self.execute(cmd)? {
            Response::Poseidon2PermutationResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Poseidon2PermutationResponse".to_string()
            )),
        }
    }

    /// Execute PedersenCommit command
    pub fn pedersen_commit(&mut self, inputs: Vec<Vec<u8>>, hash_index: u32) -> Result<PedersenCommitResponse> {
        let cmd = Command::PedersenCommit(PedersenCommit::new(inputs, hash_index));
        match self.execute(cmd)? {
            Response::PedersenCommitResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected PedersenCommitResponse".to_string()
            )),
        }
    }

    /// Execute PedersenHash command
    pub fn pedersen_hash(&mut self, inputs: Vec<Vec<u8>>, hash_index: u32) -> Result<PedersenHashResponse> {
        let cmd = Command::PedersenHash(PedersenHash::new(inputs, hash_index));
        match self.execute(cmd)? {
            Response::PedersenHashResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected PedersenHashResponse".to_string()
            )),
        }
    }

    /// Execute PedersenHashBuffer command
    pub fn pedersen_hash_buffer(&mut self, input: &[u8], hash_index: u32) -> Result<PedersenHashBufferResponse> {
        let cmd = Command::PedersenHashBuffer(PedersenHashBuffer::new(input.to_vec(), hash_index));
        match self.execute(cmd)? {
            Response::PedersenHashBufferResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected PedersenHashBufferResponse".to_string()
            )),
        }
    }

    /// Execute Blake2s command
    pub fn blake2s(&mut self, data: &[u8]) -> Result<Blake2sResponse> {
        let cmd = Command::Blake2s(Blake2s::new(data.to_vec()));
        match self.execute(cmd)? {
            Response::Blake2sResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Blake2sResponse".to_string()
            )),
        }
    }

    /// Execute Blake2sToField command
    pub fn blake2s_to_field(&mut self, data: &[u8]) -> Result<Blake2sToFieldResponse> {
        let cmd = Command::Blake2sToField(Blake2sToField::new(data.to_vec()));
        match self.execute(cmd)? {
            Response::Blake2sToFieldResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Blake2sToFieldResponse".to_string()
            )),
        }
    }

    /// Execute AesEncrypt command
    pub fn aes_encrypt(&mut self, plaintext: &[u8], iv: &[u8], key: &[u8], length: u32) -> Result<AesEncryptResponse> {
        let cmd = Command::AesEncrypt(AesEncrypt::new(plaintext.to_vec(), iv.to_vec(), key.to_vec(), length));
        match self.execute(cmd)? {
            Response::AesEncryptResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected AesEncryptResponse".to_string()
            )),
        }
    }

    /// Execute AesDecrypt command
    pub fn aes_decrypt(&mut self, ciphertext: &[u8], iv: &[u8], key: &[u8], length: u32) -> Result<AesDecryptResponse> {
        let cmd = Command::AesDecrypt(AesDecrypt::new(ciphertext.to_vec(), iv.to_vec(), key.to_vec(), length));
        match self.execute(cmd)? {
            Response::AesDecryptResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected AesDecryptResponse".to_string()
            )),
        }
    }

    /// Execute GrumpkinMul command
    pub fn grumpkin_mul(&mut self, point: GrumpkinPoint, scalar: &[u8]) -> Result<GrumpkinMulResponse> {
        let cmd = Command::GrumpkinMul(GrumpkinMul::new(point, scalar.to_vec()));
        match self.execute(cmd)? {
            Response::GrumpkinMulResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected GrumpkinMulResponse".to_string()
            )),
        }
    }

    /// Execute GrumpkinAdd command
    pub fn grumpkin_add(&mut self, point_a: GrumpkinPoint, point_b: GrumpkinPoint) -> Result<GrumpkinAddResponse> {
        let cmd = Command::GrumpkinAdd(GrumpkinAdd::new(point_a, point_b));
        match self.execute(cmd)? {
            Response::GrumpkinAddResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected GrumpkinAddResponse".to_string()
            )),
        }
    }

    /// Execute GrumpkinBatchMul command
    pub fn grumpkin_batch_mul(&mut self, points: Vec<GrumpkinPoint>, scalar: &[u8]) -> Result<GrumpkinBatchMulResponse> {
        let cmd = Command::GrumpkinBatchMul(GrumpkinBatchMul::new(points, scalar.to_vec()));
        match self.execute(cmd)? {
            Response::GrumpkinBatchMulResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected GrumpkinBatchMulResponse".to_string()
            )),
        }
    }

    /// Execute GrumpkinGetRandomFr command
    pub fn grumpkin_get_random_fr(&mut self, dummy: u8) -> Result<GrumpkinGetRandomFrResponse> {
        let cmd = Command::GrumpkinGetRandomFr(GrumpkinGetRandomFr::new(dummy));
        match self.execute(cmd)? {
            Response::GrumpkinGetRandomFrResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected GrumpkinGetRandomFrResponse".to_string()
            )),
        }
    }

    /// Execute GrumpkinReduce512 command
    pub fn grumpkin_reduce512(&mut self, input: &[u8]) -> Result<GrumpkinReduce512Response> {
        let cmd = Command::GrumpkinReduce512(GrumpkinReduce512::new(input.to_vec()));
        match self.execute(cmd)? {
            Response::GrumpkinReduce512Response(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected GrumpkinReduce512Response".to_string()
            )),
        }
    }

    /// Execute Secp256k1Mul command
    pub fn secp256k1_mul(&mut self, point: Secp256k1Point, scalar: &[u8]) -> Result<Secp256k1MulResponse> {
        let cmd = Command::Secp256k1Mul(Secp256k1Mul::new(point, scalar.to_vec()));
        match self.execute(cmd)? {
            Response::Secp256k1MulResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Secp256k1MulResponse".to_string()
            )),
        }
    }

    /// Execute Secp256k1GetRandomFr command
    pub fn secp256k1_get_random_fr(&mut self, dummy: u8) -> Result<Secp256k1GetRandomFrResponse> {
        let cmd = Command::Secp256k1GetRandomFr(Secp256k1GetRandomFr::new(dummy));
        match self.execute(cmd)? {
            Response::Secp256k1GetRandomFrResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Secp256k1GetRandomFrResponse".to_string()
            )),
        }
    }

    /// Execute Secp256k1Reduce512 command
    pub fn secp256k1_reduce512(&mut self, input: &[u8]) -> Result<Secp256k1Reduce512Response> {
        let cmd = Command::Secp256k1Reduce512(Secp256k1Reduce512::new(input.to_vec()));
        match self.execute(cmd)? {
            Response::Secp256k1Reduce512Response(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Secp256k1Reduce512Response".to_string()
            )),
        }
    }

    /// Execute Bn254FrSqrt command
    pub fn bn254_fr_sqrt(&mut self, input: &[u8]) -> Result<Bn254FrSqrtResponse> {
        let cmd = Command::Bn254FrSqrt(Bn254FrSqrt::new(input.to_vec()));
        match self.execute(cmd)? {
            Response::Bn254FrSqrtResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254FrSqrtResponse".to_string()
            )),
        }
    }

    /// Execute Bn254FqSqrt command
    pub fn bn254_fq_sqrt(&mut self, input: &[u8]) -> Result<Bn254FqSqrtResponse> {
        let cmd = Command::Bn254FqSqrt(Bn254FqSqrt::new(input.to_vec()));
        match self.execute(cmd)? {
            Response::Bn254FqSqrtResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254FqSqrtResponse".to_string()
            )),
        }
    }

    /// Execute Bn254G1Mul command
    pub fn bn254_g1_mul(&mut self, point: Bn254G1Point, scalar: &[u8]) -> Result<Bn254G1MulResponse> {
        let cmd = Command::Bn254G1Mul(Bn254G1Mul::new(point, scalar.to_vec()));
        match self.execute(cmd)? {
            Response::Bn254G1MulResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254G1MulResponse".to_string()
            )),
        }
    }

    /// Execute Bn254G2Mul command
    pub fn bn254_g2_mul(&mut self, point: Bn254G2Point, scalar: &[u8]) -> Result<Bn254G2MulResponse> {
        let cmd = Command::Bn254G2Mul(Bn254G2Mul::new(point, scalar.to_vec()));
        match self.execute(cmd)? {
            Response::Bn254G2MulResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254G2MulResponse".to_string()
            )),
        }
    }

    /// Execute Bn254G1IsOnCurve command
    pub fn bn254_g1_is_on_curve(&mut self, point: Bn254G1Point) -> Result<Bn254G1IsOnCurveResponse> {
        let cmd = Command::Bn254G1IsOnCurve(Bn254G1IsOnCurve::new(point));
        match self.execute(cmd)? {
            Response::Bn254G1IsOnCurveResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254G1IsOnCurveResponse".to_string()
            )),
        }
    }

    /// Execute Bn254G1FromCompressed command
    pub fn bn254_g1_from_compressed(&mut self, compressed: &[u8]) -> Result<Bn254G1FromCompressedResponse> {
        let cmd = Command::Bn254G1FromCompressed(Bn254G1FromCompressed::new(compressed.to_vec()));
        match self.execute(cmd)? {
            Response::Bn254G1FromCompressedResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected Bn254G1FromCompressedResponse".to_string()
            )),
        }
    }

    /// Execute SchnorrComputePublicKey command
    pub fn schnorr_compute_public_key(&mut self, private_key: &[u8]) -> Result<SchnorrComputePublicKeyResponse> {
        let cmd = Command::SchnorrComputePublicKey(SchnorrComputePublicKey::new(private_key.to_vec()));
        match self.execute(cmd)? {
            Response::SchnorrComputePublicKeyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected SchnorrComputePublicKeyResponse".to_string()
            )),
        }
    }

    /// Execute SchnorrConstructSignature command
    pub fn schnorr_construct_signature(&mut self, message: &[u8], private_key: &[u8]) -> Result<SchnorrConstructSignatureResponse> {
        let cmd = Command::SchnorrConstructSignature(SchnorrConstructSignature::new(message.to_vec(), private_key.to_vec()));
        match self.execute(cmd)? {
            Response::SchnorrConstructSignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected SchnorrConstructSignatureResponse".to_string()
            )),
        }
    }

    /// Execute SchnorrVerifySignature command
    pub fn schnorr_verify_signature(&mut self, message: &[u8], public_key: GrumpkinPoint, s: &[u8], e: &[u8]) -> Result<SchnorrVerifySignatureResponse> {
        let cmd = Command::SchnorrVerifySignature(SchnorrVerifySignature::new(message.to_vec(), public_key, s.to_vec(), e.to_vec()));
        match self.execute(cmd)? {
            Response::SchnorrVerifySignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected SchnorrVerifySignatureResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256k1ComputePublicKey command
    pub fn ecdsa_secp256k1_compute_public_key(&mut self, private_key: &[u8]) -> Result<EcdsaSecp256k1ComputePublicKeyResponse> {
        let cmd = Command::EcdsaSecp256k1ComputePublicKey(EcdsaSecp256k1ComputePublicKey::new(private_key.to_vec()));
        match self.execute(cmd)? {
            Response::EcdsaSecp256k1ComputePublicKeyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256k1ComputePublicKeyResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256r1ComputePublicKey command
    pub fn ecdsa_secp256r1_compute_public_key(&mut self, private_key: &[u8]) -> Result<EcdsaSecp256r1ComputePublicKeyResponse> {
        let cmd = Command::EcdsaSecp256r1ComputePublicKey(EcdsaSecp256r1ComputePublicKey::new(private_key.to_vec()));
        match self.execute(cmd)? {
            Response::EcdsaSecp256r1ComputePublicKeyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256r1ComputePublicKeyResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256k1ConstructSignature command
    pub fn ecdsa_secp256k1_construct_signature(&mut self, message: &[u8], private_key: &[u8]) -> Result<EcdsaSecp256k1ConstructSignatureResponse> {
        let cmd = Command::EcdsaSecp256k1ConstructSignature(EcdsaSecp256k1ConstructSignature::new(message.to_vec(), private_key.to_vec()));
        match self.execute(cmd)? {
            Response::EcdsaSecp256k1ConstructSignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256k1ConstructSignatureResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256r1ConstructSignature command
    pub fn ecdsa_secp256r1_construct_signature(&mut self, message: &[u8], private_key: &[u8]) -> Result<EcdsaSecp256r1ConstructSignatureResponse> {
        let cmd = Command::EcdsaSecp256r1ConstructSignature(EcdsaSecp256r1ConstructSignature::new(message.to_vec(), private_key.to_vec()));
        match self.execute(cmd)? {
            Response::EcdsaSecp256r1ConstructSignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256r1ConstructSignatureResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256k1RecoverPublicKey command
    pub fn ecdsa_secp256k1_recover_public_key(&mut self, message: &[u8], r: &[u8], s: &[u8], v: u8) -> Result<EcdsaSecp256k1RecoverPublicKeyResponse> {
        let cmd = Command::EcdsaSecp256k1RecoverPublicKey(EcdsaSecp256k1RecoverPublicKey::new(message.to_vec(), r.to_vec(), s.to_vec(), v));
        match self.execute(cmd)? {
            Response::EcdsaSecp256k1RecoverPublicKeyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256k1RecoverPublicKeyResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256r1RecoverPublicKey command
    pub fn ecdsa_secp256r1_recover_public_key(&mut self, message: &[u8], r: &[u8], s: &[u8], v: u8) -> Result<EcdsaSecp256r1RecoverPublicKeyResponse> {
        let cmd = Command::EcdsaSecp256r1RecoverPublicKey(EcdsaSecp256r1RecoverPublicKey::new(message.to_vec(), r.to_vec(), s.to_vec(), v));
        match self.execute(cmd)? {
            Response::EcdsaSecp256r1RecoverPublicKeyResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256r1RecoverPublicKeyResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256k1VerifySignature command
    pub fn ecdsa_secp256k1_verify_signature(&mut self, message: &[u8], public_key: Secp256k1Point, r: &[u8], s: &[u8], v: u8) -> Result<EcdsaSecp256k1VerifySignatureResponse> {
        let cmd = Command::EcdsaSecp256k1VerifySignature(EcdsaSecp256k1VerifySignature::new(message.to_vec(), public_key, r.to_vec(), s.to_vec(), v));
        match self.execute(cmd)? {
            Response::EcdsaSecp256k1VerifySignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256k1VerifySignatureResponse".to_string()
            )),
        }
    }

    /// Execute EcdsaSecp256r1VerifySignature command
    pub fn ecdsa_secp256r1_verify_signature(&mut self, message: &[u8], public_key: Secp256r1Point, r: &[u8], s: &[u8], v: u8) -> Result<EcdsaSecp256r1VerifySignatureResponse> {
        let cmd = Command::EcdsaSecp256r1VerifySignature(EcdsaSecp256r1VerifySignature::new(message.to_vec(), public_key, r.to_vec(), s.to_vec(), v));
        match self.execute(cmd)? {
            Response::EcdsaSecp256r1VerifySignatureResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected EcdsaSecp256r1VerifySignatureResponse".to_string()
            )),
        }
    }

    /// Execute SrsInitSrs command
    pub fn srs_init_srs(&mut self, points_buf: &[u8], num_points: u32, g2_point: &[u8]) -> Result<SrsInitSrsResponse> {
        let cmd = Command::SrsInitSrs(SrsInitSrs::new(points_buf.to_vec(), num_points, g2_point.to_vec()));
        match self.execute(cmd)? {
            Response::SrsInitSrsResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected SrsInitSrsResponse".to_string()
            )),
        }
    }

    /// Execute SrsInitGrumpkinSrs command
    pub fn srs_init_grumpkin_srs(&mut self, points_buf: &[u8], num_points: u32) -> Result<SrsInitGrumpkinSrsResponse> {
        let cmd = Command::SrsInitGrumpkinSrs(SrsInitGrumpkinSrs::new(points_buf.to_vec(), num_points));
        match self.execute(cmd)? {
            Response::SrsInitGrumpkinSrsResponse(resp) => Ok(resp),
            Response::ErrorResponse(err) => Err(BarretenbergError::Backend(
                err.message
            )),
            _ => Err(BarretenbergError::InvalidResponse(
                "Expected SrsInitGrumpkinSrsResponse".to_string()
            )),
        }
    }

    /// 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()
    }
}