space-data-module-sdk 0.8.4 → 0.8.6

package/src/host/browserHost.js

@@ -2,11 +2,17 @@
  * Browser host adapter for the SDN host contract.
  *
  * Mirrors the NodeHost public interface using browser-native Web APIs.
- * Plugs into createJsonHostcallBridge() exactly like NodeHost does.
+ * Plugs into createHostcallBridge() exactly like NodeHost does.
  */
 
 import { RuntimeTarget } from "../runtime/constants.js";
-import { toUint8Array } from "../utils/encoding.js";
+import {
+  base64ToBytes,
+  bytesToBase64,
+  hexToBytes,
+  toUint8Array,
+} from "../utils/encoding.js";
+import { derSignatureToRaw, rawSignatureToDer } from "../utils/ecdsaDer.js";
 import {
   parseCronExpression,
   matchesCronExpression,
@@ -36,6 +42,9 @@ export const BrowserHostSupportedCapabilities = Object.freeze([
   "crypto_key_agreement",
   "crypto_kdf",
   "wallet_sign",
+  "pubsub",
+  "storage_query",
+  "storage_write",
   "logging",
 ]);
 
@@ -72,7 +81,15 @@ export const BrowserHostSupportedOperations = Object.freeze([
   "protocol_handle.unregister",
   "protocol_dial.dial",
   "protocol.request",
-  "keyslot.get",
+  "keyslot.sign",
+  "keyslot.unwrap",
+  "storage.write",
+  "storage.query",
+  "storage.delete",
+  "pubsub.publish",
+  "pubsub.subscribe",
+  "pubsub.unsubscribe",
+  "pubsub.list_topics",
   "context.get",
   "context.set",
   "context.delete",
@@ -86,6 +103,9 @@ export const BrowserHostSupportedOperations = Object.freeze([
   "crypto.x25519.generateKeypair",
   "crypto.x25519.publicKey",
   "crypto.x25519.sharedSecret",
+  "crypto.secp256k1.publicKeyFromPrivate",
+  "crypto.secp256k1.sign",
+  "crypto.secp256k1.verify",
   "crypto.ed25519.publicKeyFromSeed",
   "crypto.ed25519.sign",
   "crypto.ed25519.verify",
@@ -150,6 +170,13 @@ function resolveCapabilityAdapters(options = {}) {
       adapters.protocolDial ??
       adapters.protocol_dial ??
       null,
+    storage:
+      options.storage ??
+      adapters.storage ??
+      adapters.storage_write ??
+      adapters.storage_query ??
+      null,
+    pubsub: options.pubsub ?? adapters.pubsub ?? null,
   };
 }
 
@@ -175,6 +202,194 @@ 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";
+const keyslotTextEncoder = new TextEncoder();
+
+// 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 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.",
+  );
+}
+
+async function resolveKeySlotMaterial(walletSignAdapter, slotId) {
+  const normalizedSlotId = String(slotId ?? "").trim();
+  if (!normalizedSlotId) {
+    throw new Error("slotId is required.");
+  }
+  const record = await invokeAdapterMethod(
+    walletSignAdapter,
+    "get",
+    { slotId: normalizedSlotId },
+    "wallet_sign",
+  );
+  const material = normalizeKeySlotMaterial(record);
+  if (material.length === 0) {
+    throw new Error(`keyslot "${normalizedSlotId}" not found`);
+  }
+  return material;
+}
+
+// keyslotSign 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 function keyslotSign(walletSignAdapter, wasmWallet, params = {}) {
+  const slotId = String(params.slotId ?? "").trim();
+  if (!slotId) {
+    throw new Error("slotId is required.");
+  }
+  const keyMaterial = await resolveKeySlotMaterial(walletSignAdapter, 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 (!wasmWallet?.curves?.ed25519?.sign) {
+      throw new Error(
+        "Browser host keyslot.sign requires a preloaded wasmWallet.",
+      );
+    }
+    if (keyMaterial.length !== 32) {
+      throw new Error(`keyslot "${slotId}" is not a 32-byte ed25519 seed`);
+    }
+    const signature = new Uint8Array(
+      wasmWallet.curves.ed25519.sign(payload, keyMaterial),
+    );
+    return { signature: bytesToBase64(signature), algorithm: "ed25519" };
+  }
+
+  if (algorithm === "secp256k1") {
+    if (!wasmWallet?.utils?.sha256 || !wasmWallet?.curves?.secp256k1?.sign) {
+      throw new Error(
+        "Browser host keyslot.sign requires a preloaded wasmWallet.",
+      );
+    }
+    if (keyMaterial.length !== 32) {
+      throw new Error(
+        `keyslot "${slotId}" is not a 32-byte secp256k1 private key`,
+      );
+    }
+    const digest = new Uint8Array(wasmWallet.utils.sha256(payload));
+    const rawSignature = new Uint8Array(
+      wasmWallet.curves.secp256k1.sign(digest, keyMaterial),
+    );
+    return {
+      signature: bytesToBase64(rawSignatureToDer(rawSignature)),
+      algorithm: "secp256k1",
+    };
+  }
+
+  throw new Error(`unsupported keyslot.sign algorithm: ${algorithm}`);
+}
+
+// keyslotUnwrap 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 function keyslotUnwrap(walletSignAdapter, wasmWallet, params = {}) {
+  const slotId = String(params.slotId ?? "").trim();
+  if (!slotId) {
+    throw new Error("slotId is required.");
+  }
+  if (
+    !wasmWallet?.curves?.x25519?.ecdh ||
+    !wasmWallet?.utils?.hkdf ||
+    !wasmWallet?.utils?.aesGcm?.decrypt
+  ) {
+    throw new Error(
+      "Browser host keyslot.unwrap requires a preloaded wasmWallet.",
+    );
+  }
+  const keyMaterial = await resolveKeySlotMaterial(walletSignAdapter, 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 = new Uint8Array(
+    wasmWallet.curves.x25519.ecdh(keyMaterial, ephemeralPublicKey),
+  );
+  const aesKey = new Uint8Array(
+    wasmWallet.utils.hkdf(
+      sharedSecret,
+      new Uint8Array(),
+      keyslotTextEncoder.encode(KEYSLOT_UNWRAP_HKDF_INFO),
+      32,
+    ),
+  );
+  const plaintext = new Uint8Array(
+    wasmWallet.utils.aesGcm.decrypt(aesKey, ciphertext, tag, nonce),
+  );
+  return { plaintext: bytesToBase64(plaintext) };
+}
+
 export class BrowserHost {
   constructor(options = {}) {
     this.runtimeTarget = RuntimeTarget.BROWSER;
@@ -214,6 +429,8 @@ export class BrowserHost {
     const walletSignAdapter = capabilityAdapters.walletSign;
     const protocolHandleAdapter = edgeShims.protocolHandle;
     const protocolDialAdapter = edgeShims.protocolDial;
+    const storageAdapter = capabilityAdapters.storage;
+    const pubsubAdapter = capabilityAdapters.pubsub;
 
     this._grantedCapabilities = granted;
     this._contextStore = options.contextStore ?? new Map();
@@ -440,10 +657,60 @@ export class BrowserHost {
       },
     });
 
+    // 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.#assertCapability("wallet_sign", "keyslot.get");
-        return invokeAdapterMethod(walletSignAdapter, "get", params, "wallet_sign");
+      sign: async (params = {}) => {
+        this.#assertCapability("wallet_sign", "keyslot.sign");
+        return keyslotSign(walletSignAdapter, wasmWallet, params);
+      },
+      unwrap: async (params = {}) => {
+        this.#assertCapability("wallet_sign", "keyslot.unwrap");
+        return keyslotUnwrap(walletSignAdapter, wasmWallet, params);
+      },
+    });
+
+    // Storage + pubsub mirror the Go node's module capability contract
+    // (sdn-server internal/modulert/caps): storage.write {schema, data:base64}
+    // -> {cid}; storage.query {schema, day, entity_id, norad_cat_id, limit};
+    // storage.delete {schema, cid}; pubsub.publish {topic, data:utf8};
+    // pubsub.subscribe/unsubscribe {topic}; pubsub.list_topics {} -> {topics}.
+    this.storage = Object.freeze({
+      write: async (params = {}) => {
+        this.#assertCapability("storage_write", "storage.write");
+        return invokeAdapterMethod(storageAdapter, "write", params, "storage");
+      },
+      query: async (params = {}) => {
+        this.#assertCapability("storage_query", "storage.query");
+        return invokeAdapterMethod(storageAdapter, "query", params, "storage");
+      },
+      delete: async (params = {}) => {
+        this.#assertCapability("storage_write", "storage.delete");
+        return invokeAdapterMethod(storageAdapter, "delete", params, "storage");
+      },
+    });
+
+    this.pubsub = Object.freeze({
+      publish: async (params = {}) => {
+        this.#assertCapability("pubsub", "pubsub.publish");
+        return invokeAdapterMethod(pubsubAdapter, "publish", params, "pubsub");
+      },
+      subscribe: async (params = {}) => {
+        this.#assertCapability("pubsub", "pubsub.subscribe");
+        return invokeAdapterMethod(pubsubAdapter, "subscribe", params, "pubsub");
+      },
+      unsubscribe: async (params = {}) => {
+        this.#assertCapability("pubsub", "pubsub.unsubscribe");
+        return invokeAdapterMethod(pubsubAdapter, "unsubscribe", params, "pubsub");
+      },
+      listTopics: async (params = {}) => {
+        this.#assertCapability("pubsub", "pubsub.list_topics");
+        return invokeAdapterMethod(pubsubAdapter, "list_topics", params, "pubsub");
       },
     });
 
@@ -590,6 +857,60 @@ export class BrowserHost {
           ),
         );
       },
+      secp256k1: Object.freeze({
+        publicKeyFromPrivate: (privateKey) => {
+          this.#assertCapability(
+            "crypto_sign",
+            "crypto.secp256k1.publicKeyFromPrivate",
+          );
+          if (!wasmWallet?.curves?.publicKeyFromPrivate) {
+            throw new Error(
+              "Browser host crypto.secp256k1.publicKeyFromPrivate requires a preloaded wasmWallet.",
+            );
+          }
+          return new Uint8Array(
+            wasmWallet.curves.publicKeyFromPrivate(toUint8Array(privateKey)),
+          );
+        },
+        sign: (message, privateKey) => {
+          this.#assertCapability("crypto_sign", "crypto.secp256k1.sign");
+          if (
+            !wasmWallet?.utils?.sha256 ||
+            !wasmWallet?.curves?.secp256k1?.sign
+          ) {
+            throw new Error(
+              "Browser host crypto.secp256k1.sign requires a preloaded wasmWallet.",
+            );
+          }
+          const digest = new Uint8Array(
+            wasmWallet.utils.sha256(toUint8Array(message)),
+          );
+          const rawSignature = new Uint8Array(
+            wasmWallet.curves.secp256k1.sign(digest, toUint8Array(privateKey)),
+          );
+          return rawSignatureToDer(rawSignature);
+        },
+        verify: (message, signature, publicKey) => {
+          this.#assertCapability("crypto_verify", "crypto.secp256k1.verify");
+          if (
+            !wasmWallet?.utils?.sha256 ||
+            !wasmWallet?.curves?.secp256k1?.verify
+          ) {
+            throw new Error(
+              "Browser host crypto.secp256k1.verify requires a preloaded wasmWallet.",
+            );
+          }
+          const digest = new Uint8Array(
+            wasmWallet.utils.sha256(toUint8Array(message)),
+          );
+          const result = wasmWallet.curves.secp256k1.verify(
+            digest,
+            derSignatureToRaw(signature),
+            toUint8Array(publicKey),
+          );
+          return { result: Boolean(result) };
+        },
+      }),
       ed25519: Object.freeze({
         publicKeyFromSeed: (seed) => {
           this.#assertCapability("crypto_sign", "crypto.ed25519.publicKeyFromSeed");
@@ -774,8 +1095,24 @@ export class BrowserHost {
         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 "storage.write":
+        return this.storage.write(params);
+      case "storage.query":
+        return this.storage.query(params);
+      case "storage.delete":
+        return this.storage.delete(params);
+      case "pubsub.publish":
+        return this.pubsub.publish(params);
+      case "pubsub.subscribe":
+        return this.pubsub.subscribe(params);
+      case "pubsub.unsubscribe":
+        return this.pubsub.unsubscribe(params);
+      case "pubsub.list_topics":
+        return this.pubsub.listTopics(params);
       case "context.get":
         return this.context.get(params.scope, params.key);
       case "context.set":
@@ -805,6 +1142,16 @@ export class BrowserHost {
           params.privateKey,
           params.publicKey,
         );
+      case "crypto.secp256k1.publicKeyFromPrivate":
+        return this.crypto.secp256k1.publicKeyFromPrivate(params.privateKey);
+      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":

package/src/host/cpp/keyslotClient.hpp

@@ -0,0 +1,231 @@
+// C++ guest-side wrapper for the `keyslot` host capability.
+//
+// Mirrors the intent of space-data-module-sdk/src/host/hostcallWire.js plus
+// the server-side handlers in
+// sdn-server/internal/modulert/caps/keyslot.go: `keyslot` is a host-side
+// crypto oracle. A module never receives a slot's private key material —
+// only the *outputs* of private-key operations cross the host/guest
+// boundary (a signature; the plaintext of a payload wrapped to a slot's
+// public key). The removed `keyslot.get` raw-export operation must never be
+// reintroduced here.
+//
+// This header assumes the including translation unit has already pulled in
+// the sdm_hostcall wire protocol (sdm_hostcall::call / Segment / Response —
+// see space-data-network-modules/common/sdm_hostcall_wire.hpp) ahead of this
+// file, since that protocol is what actually crosses the WASM import
+// boundary. Keeping that as a precondition (rather than a relative
+// #include reaching across repos) avoids a fragile cross-repo path that
+// would break depending on checkout layout.
+//
+// keyslot.sign request/response wire shape (JSON meta document; the
+// payload bytes travel as a binary segment referenced by "$bin", not
+// inline base64 — the host bridge base64-encodes it for the capability
+// handler on the way through):
+//
+//   -> {"slotId":"...", "payload":{"$bin":0}, "algorithm":"ed25519"}
+//   <- {"signature":"<base64>", "algorithm":"ed25519"}
+//
+// See sdn-server/internal/modulert/caps/keyslot.go (handleKeyslotSign) for
+// the authoritative host-side implementation.
+
+#ifndef SDM_KEYSLOT_CLIENT_HPP
+#define SDM_KEYSLOT_CLIENT_HPP
+
+#ifndef SDM_HOSTCALL_WIRE_HPP
+#error "include sdm_hostcall_wire.hpp (sdm_hostcall::call/Segment/Response) before keyslotClient.hpp"
+#endif
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace sdm_keyslot {
+
+namespace detail {
+
+inline std::string escape_json_string(std::string_view value) {
+  std::string escaped;
+  escaped.reserve(value.size());
+  for (const char c : value) {
+    switch (c) {
+      case '"':
+        escaped += "\\\"";
+        break;
+      case '\\':
+        escaped += "\\\\";
+        break;
+      case '\n':
+        escaped += "\\n";
+        break;
+      case '\r':
+        escaped += "\\r";
+        break;
+      case '\t':
+        escaped += "\\t";
+        break;
+      default:
+        escaped.push_back(c);
+        break;
+    }
+  }
+  return escaped;
+}
+
+inline int decode_base64_char(char c) {
+  if (c >= 'A' && c <= 'Z') return c - 'A';
+  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+  if (c >= '0' && c <= '9') return c - '0' + 52;
+  if (c == '+') return 62;
+  if (c == '/') return 63;
+  if (c == '=') return -2;
+  return -1;
+}
+
+inline bool decode_base64_bytes(std::string_view text, std::vector<uint8_t>* bytes_out) {
+  if (!bytes_out) {
+    return false;
+  }
+  bytes_out->clear();
+  uint32_t accumulator = 0;
+  int bits_collected = 0;
+  bool padding_seen = false;
+  for (const char c : text) {
+    if (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
+      continue;
+    }
+    const int decoded = decode_base64_char(c);
+    if (decoded == -1) {
+      return false;
+    }
+    if (decoded == -2) {
+      padding_seen = true;
+      continue;
+    }
+    if (padding_seen) {
+      return false;
+    }
+    accumulator = (accumulator << 6) | static_cast<uint32_t>(decoded);
+    bits_collected += 6;
+    if (bits_collected >= 8) {
+      bits_collected -= 8;
+      bytes_out->push_back(static_cast<uint8_t>((accumulator >> bits_collected) & 0xffu));
+    }
+  }
+  return true;
+}
+
+inline size_t skip_json_ws(std::string_view text, size_t cursor) {
+  while (cursor < text.size()) {
+    const char c = text[cursor];
+    if (c != ' ' && c != '\t' && c != '\n' && c != '\r') {
+      break;
+    }
+    ++cursor;
+  }
+  return cursor;
+}
+
+// Minimal find-key-then-read-string-value JSON scan. Good enough for the
+// small, flat `{"signature":"...","algorithm":"..."}` result documents this
+// header parses; not a general JSON parser.
+inline bool extract_json_string_field(
+    std::string_view text,
+    std::string_view field,
+    std::string* value_out) {
+  if (!value_out) {
+    return false;
+  }
+  const std::string marker = "\"" + std::string(field) + "\"";
+  const size_t field_pos = text.find(marker);
+  if (field_pos == std::string_view::npos) {
+    return false;
+  }
+  const size_t colon_pos = text.find(':', field_pos + marker.size());
+  if (colon_pos == std::string_view::npos) {
+    return false;
+  }
+  size_t cursor = skip_json_ws(text, colon_pos + 1);
+  if (cursor >= text.size() || text[cursor] != '"') {
+    return false;
+  }
+  ++cursor;
+
+  std::string out;
+  while (cursor < text.size()) {
+    const char c = text[cursor++];
+    if (c == '"') {
+      *value_out = out;
+      return true;
+    }
+    if (c == '\\') {
+      if (cursor >= text.size()) {
+        return false;
+      }
+      const char escaped = text[cursor++];
+      switch (escaped) {
+        case '"':
+        case '\\':
+        case '/':
+          out.push_back(escaped);
+          break;
+        case 'b':
+          out.push_back('\b');
+          break;
+        case 'f':
+          out.push_back('\f');
+          break;
+        case 'n':
+          out.push_back('\n');
+          break;
+        case 'r':
+          out.push_back('\r');
+          break;
+        case 't':
+          out.push_back('\t');
+          break;
+        default:
+          return false;
+      }
+      continue;
+    }
+    out.push_back(c);
+  }
+  return false;
+}
+
+}  // namespace detail
+
+// keyslot_sign asks the host to sign `data` (length `len`) using the
+// private key material held in slot `slot_id`. `algorithm` is "ed25519" (the
+// default) or "secp256k1" — it must match what the slot actually holds. The
+// slot's private key never crosses into guest memory; only the resulting
+// signature does. Returns false on any hostcall, transport, or decode
+// failure and leaves `signature_out` untouched in that case.
+inline bool keyslot_sign(
+    std::string_view slot_id,
+    const uint8_t* data,
+    size_t len,
+    std::vector<uint8_t>* signature_out,
+    std::string_view algorithm = "ed25519") {
+  if (!signature_out || slot_id.empty()) {
+    return false;
+  }
+  const std::string meta =
+      "{\"slotId\":\"" + detail::escape_json_string(slot_id) +
+      "\",\"payload\":{\"$bin\":0},\"algorithm\":\"" +
+      detail::escape_json_string(algorithm) + "\"}";
+  sdm_hostcall::Response response;
+  if (!sdm_hostcall::call("keyslot.sign", meta, {{data, len}}, &response)) {
+    return false;
+  }
+  std::string signature_base64;
+  if (!detail::extract_json_string_field(response.meta, "signature", &signature_base64)) {
+    return false;
+  }
+  return detail::decode_base64_bytes(signature_base64, signature_out);
+}
+
+}  // namespace sdm_keyslot
+
+#endif  // SDM_KEYSLOT_CLIENT_HPP