feat: add signAndGetManifestBytes() (#36)

* feat: add signAndGetManifestBytes method

* fix: wasm-opt installation path

* chore: changeset

* docs: update doc blocks

Author: emensch

.changeset/petite-weeks-own.md

@@ -0,0 +1,6 @@
+---
+'@contentauth/c2pa-wasm': patch
+'@contentauth/c2pa-web': patch
+---
+
+Add signAndGetManifestBytes() method

Cargo.lock

@@ -27,6 +27,7 @@ async-trait = "0.1.88"
 thiserror = "2.0.12"
 serde-wasm-bindgen = "0.6.5"
 serde = "1.0.219"
+serde_bytes = "0.11.19"
 
 [dependencies.web-sys]
 version = "0.3.77"

packages/c2pa-wasm/Cargo.toml

@@ -9,7 +9,7 @@ use std::io::Cursor;
 
 use c2pa::Builder;
 use js_sys::{Error as JsError, JsString};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_wasm_bindgen::Serializer;
 use wasm_bindgen::prelude::*;
 use web_sys::Blob;
@@ -27,6 +27,15 @@ pub struct WasmBuilder {
     serializer: Serializer,
 }
 
+/// Holds the bytes of an asset and manifest.
+#[derive(Deserialize, Serialize)]
+struct AssetAndManifestBytes {
+    #[serde(with = "serde_bytes")]
+    pub asset: Vec<u8>,
+    #[serde(with = "serde_bytes")]
+    pub manifest: Vec<u8>,
+}
+
 #[wasm_bindgen]
 impl WasmBuilder {
     /// Attempts to create a new `WasmBuilder` from a JSON ManifestDefinition string.
@@ -119,18 +128,55 @@ impl WasmBuilder {
         signer_definition: &SignerDefinition,
         format: &str,
         source: &Blob,
+    ) -> Result<Vec<u8>, JsError> {
+        let mut asset: Vec<u8> = Vec::new();
+
+        self.sign_internal(signer_definition, format, source, &mut asset)
+            .await?;
+
+        Ok(asset)
+    }
+
+    /// Sign an asset using the provided SignerDefinition, format, and source Blob.
+    /// Use this method to get both the manifest bytes and the bytes of the signed asset.
+    #[wasm_bindgen(js_name = signAndGetManifestBytes)]
+    pub async fn sign_and_get_manifest_bytes(
+        &mut self,
+        signer_definition: &SignerDefinition,
+        format: &str,
+        source: &Blob,
+    ) -> Result<JsValue, JsError> {
+        let mut asset: Vec<u8> = Vec::new();
+
+        let manifest = self
+            .sign_internal(signer_definition, format, source, &mut asset)
+            .await?;
+
+        let result = AssetAndManifestBytes { manifest, asset }
+            .serialize(&self.serializer)
+            .map_err(WasmError::from)?;
+
+        Ok(result)
+    }
+
+    async fn sign_internal(
+        &mut self,
+        signer_definition: &SignerDefinition,
+        format: &str,
+        source: &Blob,
+        dest: &mut Vec<u8>,
     ) -> Result<Vec<u8>, JsError> {
         let signer = WasmSigner::from_definition(&signer_definition)?;
         let mut stream = BlobStream::new(source);
 
-        let mut bytes: Vec<u8> = Vec::new();
-        let mut cursor = Cursor::new(&mut bytes);
+        let mut cursor = Cursor::new(dest);
 
-        self.builder
+        let manifest = self
+            .builder
             .sign_async(&signer, format, &mut stream, &mut cursor)
             .await
-            .unwrap();
+            .map_err(WasmError::from)?;
 
-        Ok(bytes)
+        Ok(manifest)
     }
 }

packages/c2pa-wasm/src/wasm_builder.rs

@@ -39,7 +39,6 @@ export interface Builder {
    * Sets the state of the no_embed flag. To skip embedding a manifest (e.g. for the remote-only case) set this to `true`.
    *
    * @param noEmbed Value to set the no_embed flag.
-   * @returns
    */
   setNoEmbed: (noEmbed: boolean) => Promise<void>;
 
@@ -86,12 +85,28 @@ export interface Builder {
    */
   sign: (signer: Signer, format: string, blob: Blob) => Promise<Uint8Array>;
 
+  /**
+   * Sign an asset and get both the signed asset bytes and the manifest bytes.
+   *
+   * @todo Docs coming soon
+   */
+  signAndGetManifestBytes: (
+    signer: Signer,
+    format: string,
+    blob: Blob
+  ) => Promise<ManifestAndAssetBytes>;
+
   /**
    * Dispose of this Builder, freeing the memory it occupied and preventing further use. Call this whenever the Builder is no longer needed.
    */
   free: () => Promise<void>;
 }
 
+export interface ManifestAndAssetBytes {
+  manifest: Uint8Array;
+  asset: Uint8Array;
+}
+
 /**
  * @param worker - Worker (via WorkerManager) to be associated with this reader factory.
  * @returns A {@link BuilderFactory} object containing builder creation methods.
@@ -176,6 +191,21 @@ function createBuilder(
       return result;
     },
 
+    async signAndGetManifestBytes(signer: Signer, format: string, blob: Blob) {
+      const payload = await getSerializablePayload(signer);
+      const requestId = worker.registerSignReceiver(signer.sign);
+
+      const result = await tx.builder_signAndGetManifestBytes(
+        id,
+        requestId,
+        payload,
+        format,
+        blob
+      );
+
+      return result;
+    },
+
     async free() {
       onFree();
       await tx.builder_free(id);

packages/c2pa-web/src/lib/builder.ts

@@ -116,6 +116,39 @@ rx({
     );
     return transfer(signedBytes, signedBytes.buffer);
   },
+  async builder_signAndGetManifestBytes(
+    builderId,
+    requestId,
+    payload,
+    format,
+    blob
+  ) {
+    const builder = builderMap.get(builderId);
+    const { manifest, asset } = await builder.signAndGetManifestBytes(
+      {
+        reserveSize: payload.reserveSize,
+        alg: payload.alg,
+        sign: async (bytes) => {
+          const result = await tx.sign(
+            requestId,
+            transfer(bytes, bytes.buffer),
+            payload.reserveSize
+          );
+          return result;
+        },
+      },
+      format,
+      blob
+    );
+
+    return transfer(
+      {
+        manifest,
+        asset,
+      },
+      [manifest.buffer, asset.buffer]
+    );
+  },
   builder_free(builderId) {
     const builder = builderMap.get(builderId);
     builder.free();

packages/c2pa-web/src/lib/worker.ts

@@ -7,6 +7,7 @@
  * it.
  */
 
+import { ManifestAndAssetBytes } from '../builder.js';
 import type { SerializableSigningPayload } from '../signer.js';
 
 import { channel } from 'highgain';
@@ -61,6 +62,13 @@ const { createTx, rx } = channel<{
     format: string,
     blob: Blob
   ) => Promise<Uint8Array>;
+  builder_signAndGetManifestBytes: (
+    builderId: number,
+    requestId: number,
+    payload: SerializableSigningPayload,
+    format: string,
+    blob: Blob
+  ) => Promise<ManifestAndAssetBytes>;
   builder_free: (builderId: number) => void;
 }>();
 

packages/c2pa-web/src/lib/worker/rpc.ts

@@ -56,7 +56,7 @@ const runExecutor: PromiseExecutor<BuildExecutorSchema> = async (
     // Run wasm-opt on wasm-bindgen output, optimizing for size
     const wasmOptInput = path.join(outDir, `${outputWasmName}_bg.wasm`);
 
-    const wasmOpt = getWasmOptPath(context.cwd);
+    const wasmOpt = getWasmOptPath(context.root);
     await $$`node ${wasmOpt} ${wasmOptInput} -o ${wasmOptInput} -Oz`;
 
     // Compute SRI integrity and append it to wasm-bindgen's JS output and .d.ts as an exported const
@@ -90,8 +90,8 @@ const runExecutor: PromiseExecutor<BuildExecutorSchema> = async (
 export default runExecutor;
 
 // Install wasm-opt's node wrapper if necessary and return a path to it.
-async function getWasmOptPath(cwd: string) {
-  const basePath = path.join(cwd, 'tools/nx-wasm-bindgen');
+async function getWasmOptPath(rootDir: string) {
+  const basePath = path.join(rootDir, 'tools/nx-wasm-bindgen');
   const downloadUrl = `https://github.com/WebAssembly/binaryen/releases/download/version_${WASM_OPT_VERSION}/binaryen-version_${WASM_OPT_VERSION}-node.tar.gz`;
   const downloadDir = path.join(basePath, 'download/');
   const downloadFilePath = path.join(downloadDir, 'wasm_opt.tar.gz');