chore: Update to wasmer 3.x

Cargo.toml

@@ -9,6 +9,9 @@ license = "MIT OR Apache-2.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+crate-type = ["cdylib"]
+
 [dependencies]
 acvm = { version = "0.12.0", features = ["bn254"] }
 bincode = "1.3.3"
@@ -18,23 +21,35 @@ serde = { version = "1.0.136", features = ["derive"] }
 serde-big-array = "0.5.1"
 thiserror = "1.0.21"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Native
 barretenberg-sys = { version = "0.1.2", optional = true }
 
 # Wasm
-wasmer = { version = "2.3", optional = true, default-features = false }
+getrandom = { version = "0.2", optional = true }
 rust-embed = { version = "6.6.0", optional = true, features = [
     "debug-embed",
     "interpolate-folder-path",
     "include-exclude",
 ] }
-getrandom = { version = "0.2", optional = true }
+wasmer = { version = "3.3", optional = true, default-features = false, features = [
+    "sys-default",
+    "cranelift"
+] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = [ "js" ] }
+rust-embed = { version = "6.6.0", features = [
+    "debug-embed",
+    "interpolate-folder-path",
+    "include-exclude",
+] }
+wasmer = { version = "3.3", default-features = false, features = [ "js-default" ] }
 
 [build-dependencies]
 pkg-config = "0.3"
 
-[dev-dependencies]
-blake2 = "0.10.6"
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 tokio = { version = "1.0", features = [ "macros" ] }
 
 [features]
@@ -43,18 +58,10 @@ native = [
     "dep:barretenberg-sys"
 ]
 wasm = [
-    "wasmer",
+    "dep:wasmer",
     "dep:rust-embed",
-    "dep:getrandom",
-    "wasmer/sys-default",
-    "wasmer/cranelift",
-    "wasmer/default-compiler",
-    "wasmer/default-cranelift",
-    "wasmer/default-universal"
-]
-js = [
-    "wasmer",
-    "dep:rust-embed",
-    "dep:getrandom",
-    "wasmer/js-default"
+    "dep:getrandom"
 ]
+
+[patch.crates-io]
+acvm = { git = "https://github.com/noir-lang/acvm", rev = "9f9fc216a6d09ca97352ffd365bfd347e94ad8eb" }

src/acvm_interop/common_reference_string.rs

@@ -3,7 +3,7 @@ use acvm::{acir::circuit::Circuit, async_trait, CommonReferenceString};
 use crate::{composer::Composer, BackendError, Barretenberg};
 
 // TODO(#185): Ensure CRS download works in JS
-#[async_trait]
+#[async_trait(?Send)]
 impl CommonReferenceString for Barretenberg {
     type Error = BackendError;
 

src/acvm_interop/proof_system.rs

@@ -34,7 +34,6 @@ impl ProofSystemCompiler for Barretenberg {
                 | BlackBoxFunc::SHA256
                 | BlackBoxFunc::Blake2s
                 | BlackBoxFunc::Keccak256
-                | BlackBoxFunc::ComputeMerkleRoot
                 | BlackBoxFunc::SchnorrVerify
                 | BlackBoxFunc::Pedersen
                 | BlackBoxFunc::HashToField128Security

src/acvm_interop/pwg.rs

@@ -1,17 +1,14 @@
 use acvm::acir::circuit::opcodes::FunctionInput;
 use acvm::acir::native_types::{Witness, WitnessMap};
 use acvm::acir::BlackBoxFunc;
-use acvm::pwg::{hash, logic, range, signature, witness_to_value};
-use acvm::{pwg::OpcodeResolution, FieldElement};
-use acvm::{OpcodeResolutionError, PartialWitnessGenerator};
+use acvm::pwg::{witness_to_value, OpcodeResolution, OpcodeResolutionError};
+use acvm::{FieldElement, PartialWitnessGenerator};
 
 use crate::pedersen::Pedersen;
 use crate::scalar_mul::ScalarMul;
 use crate::schnorr::SchnorrSig;
 use crate::Barretenberg;
 
-mod merkle;
-
 impl PartialWitnessGenerator for Barretenberg {
     fn aes(
         &self,
@@ -24,86 +21,6 @@ impl PartialWitnessGenerator for Barretenberg {
         ))
     }
 
-    fn and(
-        &self,
-        initial_witness: &mut WitnessMap,
-        lhs: &FunctionInput,
-        rhs: &FunctionInput,
-        output: &Witness,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        logic::and(initial_witness, lhs, rhs, output)
-    }
-
-    fn xor(
-        &self,
-        initial_witness: &mut WitnessMap,
-        lhs: &FunctionInput,
-        rhs: &FunctionInput,
-        output: &Witness,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        logic::xor(initial_witness, lhs, rhs, output)
-    }
-
-    fn range(
-        &self,
-        initial_witness: &mut WitnessMap,
-        input: &FunctionInput,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        range::solve_range_opcode(initial_witness, input)
-    }
-
-    fn sha256(
-        &self,
-        initial_witness: &mut WitnessMap,
-        inputs: &[FunctionInput],
-        outputs: &[Witness],
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        hash::sha256(initial_witness, inputs, outputs)
-    }
-
-    fn blake2s(
-        &self,
-        initial_witness: &mut WitnessMap,
-        inputs: &[FunctionInput],
-        outputs: &[Witness],
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        hash::blake2s256(initial_witness, inputs, outputs)
-    }
-
-    fn compute_merkle_root(
-        &self,
-        initial_witness: &mut WitnessMap,
-        leaf: &FunctionInput,
-        index: &FunctionInput,
-        hash_path: &[FunctionInput],
-        output: &Witness,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        let leaf = witness_to_value(initial_witness, leaf.witness)?;
-
-        let index = witness_to_value(initial_witness, index.witness)?;
-
-        let hash_path: Result<Vec<_>, _> = hash_path
-            .iter()
-            .map(|input| witness_to_value(initial_witness, input.witness))
-            .collect();
-
-        let computed_merkle_root = merkle::compute_merkle_root(
-            |left, right| self.compress_native(left, right),
-            hash_path?,
-            index,
-            leaf,
-        )
-        .map_err(|err| {
-            OpcodeResolutionError::BlackBoxFunctionFailed(
-                BlackBoxFunc::ComputeMerkleRoot,
-                err.to_string(),
-            )
-        })?;
-
-        initial_witness.insert(*output, computed_merkle_root);
-        Ok(OpcodeResolution::Solved)
-    }
-
     fn schnorr_verify(
         &self,
         initial_witness: &mut WitnessMap,
@@ -212,34 +129,6 @@ impl PartialWitnessGenerator for Barretenberg {
         Ok(OpcodeResolution::Solved)
     }
 
-    fn hash_to_field_128_security(
-        &self,
-        initial_witness: &mut WitnessMap,
-        inputs: &[FunctionInput],
-        output: &Witness,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        hash::hash_to_field_128_security(initial_witness, inputs, output)
-    }
-
-    fn ecdsa_secp256k1(
-        &self,
-        initial_witness: &mut WitnessMap,
-        public_key_x: &[FunctionInput],
-        public_key_y: &[FunctionInput],
-        signature: &[FunctionInput],
-        message: &[FunctionInput],
-        outputs: &Witness,
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        signature::ecdsa::secp256k1_prehashed(
-            initial_witness,
-            public_key_x,
-            public_key_y,
-            signature,
-            message,
-            *outputs,
-        )
-    }
-
     fn fixed_base_scalar_mul(
         &self,
         initial_witness: &mut WitnessMap,
@@ -259,13 +148,4 @@ impl PartialWitnessGenerator for Barretenberg {
         initial_witness.insert(outputs[1], pub_y);
         Ok(OpcodeResolution::Solved)
     }
-
-    fn keccak256(
-        &self,
-        initial_witness: &mut WitnessMap,
-        inputs: &[FunctionInput],
-        outputs: &[Witness],
-    ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-        hash::keccak256(initial_witness, inputs, outputs)
-    }
 }