finding 2: use JS-provided throw_or_abort_impl for WASM error recovery

In WASM builds, BB_NO_EXCEPTIONS is defined which routes throw_or_abort
to std::abort(), killing the WASM process on any error with no recovery.

Two changes fix this:

C++ side: throw_or_abort_impl now stores the error message in an
exported buffer (get_last_error_ptr/get_last_error_length) before
aborting. The abort produces a WebAssembly.RuntimeError trap that is
catchable in JS.

JS side: cbindCall() catches the WASM trap, reads the stored error
message via the exported functions, and re-throws as a proper
Error with the original message. The WASM instance stays alive.

Before: any throw_or_abort in WASM kills the process, PXE crashes.
After: the JS caller gets a catchable Error("actual error message").

Author: johnathan79717

barretenberg/cpp/src/barretenberg/env/throw_or_abort_impl.cpp

@@ -5,6 +5,29 @@
 #include <backward.hpp>
 #endif
 
+#ifdef __wasm__
+#include <cstring>
+
+// In WASM builds, store the error message in a global buffer before aborting.
+// The JS host catches the WebAssembly.RuntimeError trap and calls
+// get_last_error_ptr()/get_last_error_length() to retrieve the message.
+static constexpr size_t ERROR_BUF_SIZE = 4096;
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static char last_error_message[ERROR_BUF_SIZE]; // NOLINT(cppcoreguidelines-avoid-c-arrays)
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static size_t last_error_length = 0;
+
+WASM_EXPORT uint32_t get_last_error_length()
+{
+    return static_cast<uint32_t>(last_error_length);
+}
+
+WASM_EXPORT const char* get_last_error_ptr()
+{
+    return last_error_message;
+}
+#endif
+
 inline void abort_with_message [[noreturn]] (std::string const& err)
 {
     info("abort: ", err);
@@ -24,6 +47,15 @@ WASM_EXPORT void throw_or_abort_impl [[noreturn]] (const char* err)
 #ifndef BB_NO_EXCEPTIONS
     throw std::runtime_error(err);
 #else
+#ifdef __wasm__
+    // Store error message in exported buffer so JS can read it after the trap.
+    last_error_length = std::strlen(err);
+    if (last_error_length >= ERROR_BUF_SIZE) {
+        last_error_length = ERROR_BUF_SIZE - 1;
+    }
+    std::memcpy(last_error_message, err, last_error_length);
+    last_error_message[last_error_length] = '\0';
+#endif
     abort_with_message(err);
 #endif
 }

barretenberg/ts/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -222,8 +222,27 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     view.setUint32(outputPtrLocation, scratchDataPtr, true);
     view.setUint32(outputSizeLocation, scratchDataSize, true);
 
-    // Call WASM
-    this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+    // Call WASM. If C++ calls throw_or_abort, it stores the error message in
+    // last_error_message and aborts, producing a WebAssembly.RuntimeError trap.
+    // We catch the trap and re-throw with the actual error message.
+    try {
+      this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+    } catch (e) {
+      // Free custom input buffer before re-throwing
+      if (needsCustomInputBuffer) {
+        try {
+          this.call('bbfree', inputPtr);
+        } catch {
+          // WASM state may be inconsistent after trap, ignore cleanup failure
+        }
+      }
+      // Read the error message stored by throw_or_abort_impl before the trap
+      const errMsg = this.readLastErrorMessage();
+      if (errMsg) {
+        throw new Error(errMsg);
+      }
+      throw e;
+    }
 
     // Free custom input buffer if allocated
     if (needsCustomInputBuffer) {
@@ -251,6 +270,24 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
 
     return encodedResult;
   }
+
+  /**
+   * Read the error message stored by throw_or_abort_impl before a WASM trap.
+   * Returns the message string, or undefined if no message was stored.
+   */
+  private readLastErrorMessage(): string | undefined {
+    try {
+      const length = this.call('get_last_error_length');
+      if (length === 0) {
+        return undefined;
+      }
+      const ptr = this.call('get_last_error_ptr');
+      const bytes = new Uint8Array(this.getMemory().buffer, ptr, length);
+      return new TextDecoder().decode(bytes);
+    } catch {
+      return undefined;
+    }
+  }
 }
 
 /**