space-data-module-sdk 0.8.4 → 0.8.6

package/src/host/hostcallWire.js

@@ -0,0 +1,183 @@
+/**
+ * Binary hostcall wire format.
+ *
+ * Replaces the JSON+base64 hostcall round-trip: binary payloads cross the
+ * host<->module boundary as raw length-prefixed segments, with a small JSON
+ * "meta" document carrying only control metadata. Byte values inside the
+ * meta document are represented as `{ "$bin": <segmentIndex> }` references.
+ *
+ * Envelope layout (little-endian):
+ *   u32 metaLength
+ *   u8[metaLength]   meta JSON (UTF-8)
+ *   u32 segmentCount
+ *   repeat segmentCount times:
+ *     u32 segmentLength
+ *     u8[segmentLength] segment bytes
+ *
+ * The same envelope is used for hostcall requests (meta = params) and
+ * responses (meta = { ok, result } | { ok, error }).
+ */
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+export const HOSTCALL_BINARY_REF_KEY = "$bin";
+
+function isByteValue(value) {
+  return (
+    value instanceof Uint8Array ||
+    value instanceof ArrayBuffer ||
+    ArrayBuffer.isView(value)
+  );
+}
+
+function toBytes(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+
+/**
+ * Walk a structured value, detaching binary leaves into `segments` and
+ * replacing them with `{ "$bin": index }` references. Dates become ISO
+ * strings and bigints become decimal strings (JSON-safe control metadata).
+ */
+export function detachBinaryValues(value, segments) {
+  if (value === undefined || value === null) {
+    return value ?? null;
+  }
+  if (isByteValue(value)) {
+    const index = segments.length;
+    segments.push(toBytes(value));
+    return { [HOSTCALL_BINARY_REF_KEY]: index };
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => detachBinaryValues(entry, segments));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .map(([key, entry]) => [key, detachBinaryValues(entry, segments)]),
+    );
+  }
+  return value;
+}
+
+/**
+ * Inverse of detachBinaryValues: re-attach segment bytes wherever the meta
+ * document references them.
+ */
+export function attachBinaryValues(value, segments) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => attachBinaryValues(entry, segments));
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 1 && keys[0] === HOSTCALL_BINARY_REF_KEY) {
+      const index = value[HOSTCALL_BINARY_REF_KEY];
+      if (!Number.isInteger(index) || index < 0 || index >= segments.length) {
+        throw new RangeError(
+          `Hostcall envelope references missing binary segment ${index}.`,
+        );
+      }
+      return segments[index];
+    }
+    return Object.fromEntries(
+      keys.map((key) => [key, attachBinaryValues(value[key], segments)]),
+    );
+  }
+  return value;
+}
+
+export function encodeHostcallEnvelope(meta, segments = []) {
+  const metaBytes = textEncoder.encode(JSON.stringify(meta ?? null));
+  let total = 4 + metaBytes.length + 4;
+  for (const segment of segments) {
+    total += 4 + segment.length;
+  }
+
+  const bytes = new Uint8Array(total);
+  const view = new DataView(bytes.buffer);
+  let offset = 0;
+  view.setUint32(offset, metaBytes.length, true);
+  offset += 4;
+  bytes.set(metaBytes, offset);
+  offset += metaBytes.length;
+  view.setUint32(offset, segments.length, true);
+  offset += 4;
+  for (const segment of segments) {
+    view.setUint32(offset, segment.length, true);
+    offset += 4;
+    bytes.set(segment, offset);
+    offset += segment.length;
+  }
+  return bytes;
+}
+
+export function decodeHostcallEnvelope(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError("Hostcall envelope must be a Uint8Array.");
+  }
+  if (bytes.length < 8) {
+    throw new RangeError("Hostcall envelope is truncated.");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 0;
+  const metaLength = view.getUint32(offset, true);
+  offset += 4;
+  if (offset + metaLength + 4 > bytes.length) {
+    throw new RangeError("Hostcall envelope meta exceeds envelope bounds.");
+  }
+  const meta = JSON.parse(
+    textDecoder.decode(bytes.subarray(offset, offset + metaLength)),
+  );
+  offset += metaLength;
+  const segmentCount = view.getUint32(offset, true);
+  offset += 4;
+  const segments = [];
+  for (let index = 0; index < segmentCount; index += 1) {
+    if (offset + 4 > bytes.length) {
+      throw new RangeError("Hostcall envelope segment table is truncated.");
+    }
+    const segmentLength = view.getUint32(offset, true);
+    offset += 4;
+    if (offset + segmentLength > bytes.length) {
+      throw new RangeError("Hostcall envelope segment exceeds envelope bounds.");
+    }
+    segments.push(bytes.subarray(offset, offset + segmentLength));
+    offset += segmentLength;
+  }
+  return { meta, segments };
+}
+
+/**
+ * Encode a structured value (params or result) into an envelope, detaching
+ * binary leaves into segments.
+ */
+export function encodeHostcallValueEnvelope(value) {
+  const segments = [];
+  const meta = detachBinaryValues(value, segments);
+  return encodeHostcallEnvelope(meta, segments);
+}
+
+/**
+ * Decode an envelope back into a structured value with bytes re-attached.
+ */
+export function decodeHostcallValueEnvelope(bytes) {
+  const { meta, segments } = decodeHostcallEnvelope(bytes);
+  return attachBinaryValues(meta, segments);
+}

package/src/host/index.js

@@ -5,3 +5,5 @@ export * from "./browserEdgeShims.js";
 export * from "./wasiShim.js";
 export * from "./isomorphicLoader.js";
 export * from "./abi.js";
+export * from "./sabHostcallChannel.js";
+export * from "./timerDriver.js";

package/src/host/isomorphicLoader.js

@@ -3,7 +3,7 @@
  *
  * Unified entry point that detects the runtime environment and artifact
  * profile, then loads the module through the appropriate path:
- *   - Browser: createBrowserModuleHarness (WASI shim + optional sdn_host)
+ *   - Browser: createBrowserModuleHarness (WASI shim + optional space_data_module_host)
  *   - Node/WasmEdge: createModuleHarness (subprocess)
  *
  * The same compiled .wasm artifact works in both environments.
@@ -12,8 +12,13 @@
 import {
   createBrowserModuleHarness,
   detectArtifactProfile,
+  toLoadableWasmBytes,
 } from "../testing/browserModuleHarness.js";
 import { createAsyncHostDispatcher } from "./abi.js";
+import {
+  resolveModuleSignaturePolicy,
+  verifyModuleArtifact,
+} from "../bundle/signing.js";
 
 const isBrowser =
   typeof globalThis.window !== "undefined" &&
@@ -54,7 +59,13 @@ async function createWasmEdgeCommandHarness(options = {}) {
   const path = pathModule.default ?? pathModule;
   const wasmPath = path.resolve(String(options.wasmSource));
   const wasmBytes = await readFile(wasmPath);
-  const inspection = await inspectModule(wasmBytes);
+  // Signed/published artifacts carry an appended publication record
+  // collection that WasmEdge rejects ("malformed section id"). Strip to the
+  // canonical module payload; if anything was stripped, launch WasmEdge from
+  // a temp copy of the stripped bytes (signature verification, when
+  // requested, already ran against the full artifact in loadModule()).
+  const loadableBytes = toLoadableWasmBytes(wasmBytes);
+  const inspection = await inspectModule(loadableBytes);
 
   if (!inspection.exports.includes(DefaultInvokeExports.commandSymbol)) {
     throw new Error(
@@ -62,10 +73,23 @@ async function createWasmEdgeCommandHarness(options = {}) {
     );
   }
 
+  let launchWasmPath = wasmPath;
+  let tempArtifactDir = null;
+  if (loadableBytes.byteLength !== wasmBytes.byteLength) {
+    const [{ mkdtemp, writeFile }, osModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+    ]);
+    const os = osModule.default ?? osModule;
+    tempArtifactDir = await mkdtemp(path.join(os.tmpdir(), "sdm-module-"));
+    launchWasmPath = path.join(tempArtifactDir, "module.wasm");
+    await writeFile(launchWasmPath, loadableBytes);
+  }
+
   const command = options.wasmEdgeBinary ?? "wasmedge";
   const args = [
     ...(options.enableThreads === false ? [] : ["--enable-threads"]),
-    wasmPath,
+    launchWasmPath,
     ...(Array.isArray(options.args) ? options.args : []),
   ];
   const launchPlan = {
@@ -73,7 +97,7 @@ async function createWasmEdgeCommandHarness(options = {}) {
     args,
     env: buildWasmEdgeSpawnEnv(options.env),
     cwd: options.cwd ?? process.cwd(),
-    wasmPath,
+    wasmPath: launchWasmPath,
   };
 
   async function invokeRaw(requestBytes) {
@@ -146,7 +170,13 @@ async function createWasmEdgeCommandHarness(options = {}) {
     readManifest() {
       return null;
     },
-    async destroy() {},
+    async destroy() {
+      if (tempArtifactDir) {
+        const { rm } = await import("node:fs/promises");
+        await rm(tempArtifactDir, { recursive: true, force: true });
+        tempArtifactDir = null;
+      }
+    },
   };
 }
 
@@ -164,6 +194,7 @@ async function createWasmEdgeCommandHarness(options = {}) {
  * @returns {Promise<Object>} Harness with invoke(), readManifest(), destroy().
  */
 export async function loadModule(options = {}) {
+  const signaturePolicy = resolveModuleSignaturePolicy(options);
   if (isBrowser) {
     return createBrowserModuleHarness(options);
   }
@@ -176,6 +207,11 @@ export async function loadModule(options = {}) {
     );
   }
 
+  if (signaturePolicy) {
+    const { readFile } = await import("node:fs/promises");
+    await verifyModuleArtifact(await readFile(source), signaturePolicy);
+  }
+
   const runtimeKind = options.runtimeKind ?? "wasmedge";
   if (runtimeKind === "wasmedge") {
     const runtimeHostRequested =
@@ -187,7 +223,7 @@ export async function loadModule(options = {}) {
       const { readFile } = await import("node:fs/promises");
       const inspection = await inspectModule(await readFile(source));
       if (
-        (inspection.profile === "standalone" || inspection.profile === "sdn-abi") &&
+        (inspection.profile === "standalone" || inspection.profile === "module-host-abi") &&
         inspection.exports.includes("_start")
       ) {
         return attachHostDispatch(
@@ -247,7 +283,8 @@ export async function inspectModule(source) {
   } else {
     const bytes =
       source instanceof ArrayBuffer ? new Uint8Array(source) : source;
-    wasmModule = await WebAssembly.compile(bytes);
+    // Tolerate signed/published artifacts (appended publication records).
+    wasmModule = await WebAssembly.compile(toLoadableWasmBytes(bytes));
   }
 
   const profile = detectArtifactProfile(wasmModule);

package/src/host/nodeHost.js

@@ -14,7 +14,12 @@ import {
 } from "../transport/pki.js";
 import { RuntimeTarget } from "../runtime/constants.js";
 import { sha256Bytes } from "../utils/crypto.js";
-import { toUint8Array } from "../utils/encoding.js";
+import {
+  base64ToBytes,
+  bytesToBase64,
+  hexToBytes,
+  toUint8Array,
+} from "../utils/encoding.js";
 import {
   aesGcmDecrypt,
   aesGcmEncrypt,
@@ -29,6 +34,7 @@ import {
   x25519PublicKey,
   x25519SharedSecret,
 } from "../utils/wasmCrypto.js";
+import { derSignatureToRaw, rawSignatureToDer } from "../utils/ecdsaDer.js";
 import {
   matchesCronExpression,
   nextCronOccurrence,
@@ -100,7 +106,8 @@ export const NodeHostSupportedOperations = Object.freeze([
   "protocol_handle.unregister",
   "protocol_dial.dial",
   "protocol.request",
-  "keyslot.get",
+  "keyslot.sign",
+  "keyslot.unwrap",
   "exec.execFile",
   "context.get",
   "context.set",
@@ -120,6 +127,8 @@ export const NodeHostSupportedOperations = Object.freeze([
   "crypto.secp256k1.publicKeyFromPrivate",
   "crypto.secp256k1.signDigest",
   "crypto.secp256k1.verifyDigest",
+  "crypto.secp256k1.sign",
+  "crypto.secp256k1.verify",
   "crypto.ed25519.publicKeyFromSeed",
   "crypto.ed25519.sign",
   "crypto.ed25519.verify",
@@ -146,11 +155,15 @@ function assertNonNegativeInteger(value, label) {
 }
 
 function normalizeGrantedCapabilities(options) {
+  // Default-deny: a NodeHost constructed without an explicit grant exposes no
+  // capabilities. Every capability must be granted via grantedCapabilities,
+  // capabilities, or manifest.capabilities; requests then fail closed through
+  // assertCapability().
   const source =
     options.grantedCapabilities ??
     options.capabilities ??
     options.manifest?.capabilities ??
-    NodeHostSupportedCapabilities;
+    [];
   if (!Array.isArray(source)) {
     throw new TypeError(
       "Node host capabilities must be an array when provided.",
@@ -310,6 +323,52 @@ async function invokeAdapterMethod(adapter, methodName, params, label) {
   );
 }
 
+// keyslotUnwrapHKDFInfo domain-separates the HKDF step of keyslot.unwrap from
+// every other HKDF use in this host (e.g. crypto.hkdf). Must match the Go
+// reference implementation's keyslotUnwrapHKDFInfo constant
+// (sdn-server/internal/modulert/caps/keyslot.go) exactly, or wrapped
+// payloads produced against one host will fail to unwrap on the other.
+const KEYSLOT_UNWRAP_HKDF_INFO = "sdn-server/keyslot.unwrap/v1";
+
+// normalizeKeySlotMaterial accepts the raw key-slot secret returned by a
+// host-supplied walletSign adapter's internal "get" resolver and coerces it
+// to a Uint8Array. This resolver is never exposed to the guest directly
+// (there is no "keyslot.get" hostcall) — it only feeds the host-side
+// keyslot.sign / keyslot.unwrap crypto oracle implemented below, mirroring
+// Go's resolveKeySlot() in keyslot.go. Callers MUST NOT return the result of
+// this function, or any encoding of it, to the guest.
+function normalizeKeySlotMaterial(raw) {
+  if (raw instanceof Uint8Array) {
+    return raw;
+  }
+  if (raw instanceof ArrayBuffer) {
+    return new Uint8Array(raw);
+  }
+  if (ArrayBuffer.isView(raw)) {
+    return toUint8Array(raw);
+  }
+  if (typeof raw === "string") {
+    return base64ToBytes(raw);
+  }
+  if (raw && typeof raw === "object") {
+    if (raw.base64 !== undefined) {
+      return base64ToBytes(raw.base64);
+    }
+    if (raw.hex !== undefined) {
+      return hexToBytes(raw.hex);
+    }
+    if (raw.value !== undefined) {
+      return normalizeKeySlotMaterial(raw.value);
+    }
+    if (raw.bytes !== undefined) {
+      return normalizeKeySlotMaterial(raw.bytes);
+    }
+  }
+  throw new Error(
+    "wallet_sign adapter returned an unrecognized key-slot material shape.",
+  );
+}
+
 function normalizeFilesystemRoot(rootPath) {
   return path.resolve(String(rootPath ?? process.cwd()));
 }
@@ -2044,10 +2103,21 @@ export class NodeHost {
         ),
     });
 
+    // keyslot is a host-side crypto oracle (parity with the Go node's
+    // internal/modulert/caps/keyslot.go): it never returns a slot's private
+    // key material to the guest. Guests get the *outputs* of private-key
+    // operations (a signature, or the plaintext that was wrapped to a
+    // slot's public key) — never the key itself. There is no "keyslot.get"
+    // raw-export operation; unknown keyslot operations fail closed via the
+    // default branch of invoke()'s switch below.
     this.keyslot = Object.freeze({
-      get: async (params = {}) =>
-        this.#withCapability("wallet_sign", "keyslot.get", async () =>
-          invokeAdapterMethod(this._walletSignAdapter, "get", params, "wallet_sign"),
+      sign: async (params = {}) =>
+        this.#withCapability("wallet_sign", "keyslot.sign", async () =>
+          this.#keyslotSign(params),
+        ),
+      unwrap: async (params = {}) =>
+        this.#withCapability("wallet_sign", "keyslot.unwrap", async () =>
+          this.#keyslotUnwrap(params),
         ),
     });
   }
@@ -2201,8 +2271,10 @@ export class NodeHost {
         return this.protocolDial.dial(params);
       case "protocol.request":
         return this.protocolDial.request(params);
-      case "keyslot.get":
-        return this.keyslot.get(params);
+      case "keyslot.sign":
+        return this.keyslot.sign(params);
+      case "keyslot.unwrap":
+        return this.keyslot.unwrap(params);
       case "exec.execFile":
         return this.exec.execFile(params);
       case "context.get":
@@ -2251,6 +2323,14 @@ export class NodeHost {
           params.signature,
           params.publicKey,
         );
+      case "crypto.secp256k1.sign":
+        return this.crypto.secp256k1.sign(params.message, params.privateKey);
+      case "crypto.secp256k1.verify":
+        return this.crypto.secp256k1.verify(
+          params.message,
+          params.signature,
+          params.publicKey,
+        );
       case "crypto.ed25519.publicKeyFromSeed":
         return this.crypto.ed25519.publicKeyFromSeed(params.seed);
       case "crypto.ed25519.sign":
@@ -2379,6 +2459,32 @@ export class NodeHost {
               toUint8Array(publicKey),
             ),
         ),
+      // Message-based ECDSA-DER contract (parity with the Go/C++ hosts and the
+      // synchronous host-crypto ABI): sha256 the message internally, then use
+      // the digest-based primitives with DER <-> raw conversion.
+      sign: async (message, privateKey) =>
+        this.#withCapability("crypto_sign", "crypto.secp256k1.sign", async () => {
+          const digest = await sha256Bytes(toUint8Array(message));
+          const rawSignature = await secp256k1SignDigest(
+            toUint8Array(digest),
+            toUint8Array(privateKey),
+          );
+          return rawSignatureToDer(rawSignature);
+        }),
+      verify: async (message, signature, publicKey) =>
+        this.#withCapability(
+          "crypto_verify",
+          "crypto.secp256k1.verify",
+          async () => {
+            const digest = await sha256Bytes(toUint8Array(message));
+            const result = await secp256k1VerifyDigest(
+              toUint8Array(digest),
+              derSignatureToRaw(signature),
+              toUint8Array(publicKey),
+            );
+            return { result: Boolean(result) };
+          },
+        ),
     }),
     ed25519: Object.freeze({
       publicKeyFromSeed: async (seed) =>
@@ -2432,6 +2538,119 @@ export class NodeHost {
     this.assertCapability(capability, operation);
     return callback();
   }
+
+  // resolveKeySlotMaterial looks up a slot's private key material via the
+  // host-supplied walletSign adapter. The returned Uint8Array MUST NOT be
+  // mutated (it may alias the adapter's live key store) and MUST NOT be
+  // returned, or any encoding of it, to the guest. Only derived outputs
+  // (signatures, decrypted plaintext of a wrapped payload) may cross the
+  // host/guest boundary. Mirrors resolveKeySlot() in keyslot.go.
+  async #resolveKeySlotMaterial(slotId) {
+    const normalizedSlotId = assertNonEmptyString(slotId, "slotId");
+    const record = await invokeAdapterMethod(
+      this._walletSignAdapter,
+      "get",
+      { slotId: normalizedSlotId },
+      "wallet_sign",
+    );
+    const material = normalizeKeySlotMaterial(record);
+    if (material.length === 0) {
+      throw new Error(`keyslot "${normalizedSlotId}" not found`);
+    }
+    return material;
+  }
+
+  // keyslot.sign performs a host-side signature over a guest-supplied
+  // payload using the named slot's private key. Request:
+  //   {slotId, payload: base64, algorithm?: "ed25519" | "secp256k1"}
+  // algorithm defaults to "ed25519". Response:
+  //   {signature: base64, algorithm}
+  // The slot's key material never appears in the response. Mirrors
+  // handleKeyslotSign() in keyslot.go.
+  async #keyslotSign(params = {}) {
+    const slotId = assertNonEmptyString(params.slotId, "slotId");
+    const keyMaterial = await this.#resolveKeySlotMaterial(slotId);
+    const payload =
+      params.payload === undefined || params.payload === null
+        ? new Uint8Array()
+        : base64ToBytes(String(params.payload));
+    const algorithm = String(params.algorithm ?? "").trim() || "ed25519";
+
+    if (algorithm === "ed25519") {
+      if (keyMaterial.length !== 32) {
+        throw new Error(`keyslot "${slotId}" is not a 32-byte ed25519 seed`);
+      }
+      const signature = await ed25519Sign(payload, keyMaterial);
+      return { signature: bytesToBase64(signature), algorithm: "ed25519" };
+    }
+
+    if (algorithm === "secp256k1") {
+      if (keyMaterial.length !== 32) {
+        throw new Error(
+          `keyslot "${slotId}" is not a 32-byte secp256k1 private key`,
+        );
+      }
+      const digest = await sha256Bytes(payload);
+      const rawSignature = await secp256k1SignDigest(digest, keyMaterial);
+      return {
+        signature: bytesToBase64(rawSignatureToDer(rawSignature)),
+        algorithm: "secp256k1",
+      };
+    }
+
+    throw new Error(`unsupported keyslot.sign algorithm: ${algorithm}`);
+  }
+
+  // keyslot.unwrap decrypts a payload that was sealed to a slot's X25519
+  // public key, returning only the decrypted plaintext (e.g. a licensing
+  // content key) — never the slot's private key. Wrap scheme is
+  // ephemeral-sender ECIES: X25519(slotPrivateKey, ephemeralPublicKey) ->
+  // HKDF-SHA256 -> AES-256-GCM. Request:
+  //   {slotId, ephemeralPublicKey: base64, nonce: base64, ciphertext: base64}
+  // Response: {plaintext: base64}. Mirrors handleKeyslotUnwrap() in
+  // keyslot.go, including the wire format where `ciphertext` is
+  // (ciphertext || 16-byte GCM tag), per Go's crypto/cipher.GCM convention.
+  async #keyslotUnwrap(params = {}) {
+    const slotId = assertNonEmptyString(params.slotId, "slotId");
+    const keyMaterial = await this.#resolveKeySlotMaterial(slotId);
+    if (keyMaterial.length !== 32) {
+      throw new Error(
+        `keyslot "${slotId}" is not a 32-byte x25519 private key`,
+      );
+    }
+
+    const ephemeralPublicKey = base64ToBytes(
+      String(params.ephemeralPublicKey ?? ""),
+    );
+    const nonce = base64ToBytes(String(params.nonce ?? ""));
+    const wireCiphertext = base64ToBytes(String(params.ciphertext ?? ""));
+    if (ephemeralPublicKey.length === 0 || wireCiphertext.length === 0) {
+      throw new Error(
+        "keyslot.unwrap requires ephemeralPublicKey and ciphertext",
+      );
+    }
+    if (wireCiphertext.length < 16) {
+      throw new Error(
+        "keyslot.unwrap ciphertext is too short to contain a GCM tag",
+      );
+    }
+    const tagStart = wireCiphertext.length - 16;
+    const ciphertext = wireCiphertext.subarray(0, tagStart);
+    const tag = wireCiphertext.subarray(tagStart);
+
+    const sharedSecret = await x25519SharedSecret(
+      keyMaterial,
+      ephemeralPublicKey,
+    );
+    const aesKey = await hkdfBytes(
+      sharedSecret,
+      new Uint8Array(),
+      textEncoder.encode(KEYSLOT_UNWRAP_HKDF_INFO),
+      32,
+    );
+    const plaintext = await aesGcmDecrypt(aesKey, ciphertext, tag, nonce);
+    return { plaintext: bytesToBase64(plaintext) };
+  }
 }
 
 export function createNodeHost(options = {}) {