@le-space/ui 0.9.9 → 0.11.0

package/shared/index.js

@@ -96,7 +96,7 @@ var RECENT_INSTANCE_RUNTIME_GRACE_MS = 10 * 60 * 1e3;
 var DEPLOYMENT_PENDING_WARNING_MS = 3 * 60 * 1e3;
 
 // src/shared/package-version.ts
-var UI_PACKAGE_VERSION = "0.9.9";
+var UI_PACKAGE_VERSION = "0.11.0";
 
 // src/shared/format.ts
 function shortHash(value, head = 8, tail = 6) {
@@ -143,6 +143,16 @@ function joinRequiredPortForwards(portForwards) {
     return `${entry.port}/${protocols}`;
   }).join(" \xB7 ");
 }
+function formatCrnOptionLabel(option, confidential = false) {
+  const parts = [option.name ?? option.hash.slice(0, 8)];
+  if (option.score != null) parts.push(option.score.toFixed(2));
+  if (confidential) {
+    if (option.country) parts.push(option.country);
+    if (option.version) parts.push(`aleph-vm ${option.version}`);
+    if (option.operator) parts.push(`operator ${option.operator}`);
+  }
+  return parts.join(" \xB7 ");
+}
 
 // ../browser/src/http.ts
 async function fetchWithTimeout(input, init = {}, timeoutMs = 15e3) {
@@ -952,54 +962,6 @@ function resolveManifestSource(args) {
 
 // src/shared/wallet-controller.ts
 import { getAddress } from "viem";
-function getEthereumProvider() {
-  return globalThis.window?.ethereum ?? null;
-}
-function toChecksumAddress(address) {
-  try {
-    return getAddress(address);
-  } catch {
-    throw new Error("Invalid EVM address.");
-  }
-}
-async function connectWallet(provider = getEthereumProvider()) {
-  if (!provider) {
-    throw new Error("MetaMask provider not found.");
-  }
-  const accounts = await provider.request({
-    method: "eth_requestAccounts"
-  });
-  const chainId = await provider.request({ method: "eth_chainId" });
-  const address = accounts[0] ? toChecksumAddress(accounts[0]) : null;
-  return {
-    connected: Boolean(address),
-    address,
-    chainId,
-    isMetaMask: Boolean(provider.isMetaMask)
-  };
-}
-async function personalSign(address, message, provider = getEthereumProvider()) {
-  if (!provider) {
-    throw new Error("MetaMask provider not found.");
-  }
-  const payload = `0x${Array.from(new TextEncoder().encode(message)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
-  return provider.request({
-    method: "personal_sign",
-    params: [payload, address]
-  });
-}
-function watchWallet(onChange, provider = getEthereumProvider()) {
-  if (!provider?.on || !provider?.removeListener) {
-    return () => {
-    };
-  }
-  provider.on("accountsChanged", onChange);
-  provider.on("chainChanged", onChange);
-  return () => {
-    provider.removeListener?.("accountsChanged", onChange);
-    provider.removeListener?.("chainChanged", onChange);
-  };
-}
 
 // ../browser/src/client.ts
 function normalizeApiHost(value) {
@@ -1090,18 +1052,65 @@ function createAlephBrowserClient(options = {}) {
   };
 }
 
+// ../browser/src/wallet.ts
+function getEthereumProvider() {
+  return globalThis.window?.ethereum ?? null;
+}
+async function connectWallet(provider = getEthereumProvider(), options = {}) {
+  if (!provider) {
+    throw new Error("MetaMask provider not found.");
+  }
+  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const chainId = await provider.request({ method: "eth_chainId" });
+  const account = accounts?.[0];
+  const address = account ? options.normaliseAddress?.(account) ?? account : null;
+  return {
+    connected: Boolean(address),
+    address,
+    chainId,
+    isMetaMask: Boolean(provider.isMetaMask)
+  };
+}
+function watchWallet(onChange, provider = getEthereumProvider()) {
+  if (!provider?.on || !provider?.removeListener) {
+    return () => {
+    };
+  }
+  provider.on("accountsChanged", onChange);
+  provider.on("chainChanged", onChange);
+  return () => {
+    provider.removeListener?.("accountsChanged", onChange);
+    provider.removeListener?.("chainChanged", onChange);
+  };
+}
+
+// ../browser/src/evm.ts
+function assertProvider(provider) {
+  if (!provider) {
+    throw new Error("MetaMask provider not found.");
+  }
+}
+async function personalSign(address, message, provider = getEthereumProvider()) {
+  assertProvider(provider);
+  const hexMessage = `0x${Array.from(new TextEncoder().encode(message)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  return provider.request({
+    method: "personal_sign",
+    params: [hexMessage, address]
+  });
+}
+
 // ../browser/src/pricing.ts
 var DEFAULT_ALEPH_AGGREGATE_ADDRESS = "0xFba561a84A537fCaa567bb7A2257e7142701ae2A";
-function parseInstancePricing(payload) {
+function parseInstancePricing(payload, kind = "instance") {
   const data = payload;
   const pricing = data.data?.pricing ?? data.pricing;
-  const instance = pricing?.instance;
+  const instance = pricing?.[kind];
   if (!instance?.price?.compute_unit || !instance.compute_unit || !Array.isArray(instance.tiers)) {
-    throw new Error("Aleph pricing aggregate does not contain instance pricing.");
+    throw new Error(`Aleph pricing aggregate does not contain ${kind} pricing.`);
   }
   return instance;
 }
-async function fetchInstancePricing(apiHost = DEFAULT_ALEPH_API_HOST, aggregateAddress = DEFAULT_ALEPH_AGGREGATE_ADDRESS) {
+async function fetchInstancePricing(apiHost = DEFAULT_ALEPH_API_HOST, aggregateAddress = DEFAULT_ALEPH_AGGREGATE_ADDRESS, kind = "instance") {
   const response = await fetchWithTimeout(`${apiHost}/api/v0/aggregates/${aggregateAddress}.json?keys=pricing`, {
     cache: "no-cache"
   });
@@ -1114,17 +1123,539 @@ async function fetchInstancePricing(apiHost = DEFAULT_ALEPH_API_HOST, aggregateA
     throw new Error("Pricing aggregate response did not include a pricing key.");
   }
   return {
-    pricing: parseInstancePricing({ pricing: pricingAggregate }),
+    pricing: parseInstancePricing({ pricing: pricingAggregate }, kind),
     fetchedAt: Date.now()
   };
 }
 
+// ../attest-wasm/js/index.mjs
+async function verifyAttestation({
+  wasm,
+  report,
+  product,
+  expectedMeasurements,
+  expectedPolicy,
+  minTcb,
+  fetch: fetchImpl = globalThis.fetch,
+  nowSeconds = Date.now() / 1e3,
+  sleep: sleep2
+}) {
+  if (!Array.isArray(expectedMeasurements) || expectedMeasurements.length === 0) {
+    throw new Error("verifyAttestation needs the launch measurements the INSTANCE message pins");
+  }
+  product = product ?? wasm.detectProduct(report);
+  if (!product) throw new Error("the report does not name its AMD product line (older firmware); pass product");
+  const info = wasm.reportInfo(report, product);
+  const [vcek, crl] = await Promise.all([
+    fetchBytes(fetchImpl, info.vcekUrl, "VCEK", { sleep: sleep2 }),
+    fetchBytes(fetchImpl, info.crlUrl, "CRL", { sleep: sleep2 })
+  ]);
+  return wasm.verifyReport(
+    report,
+    product,
+    vcek,
+    crl,
+    nowSeconds,
+    expectedMeasurements,
+    expectedPolicy == null ? null : String(expectedPolicy),
+    minTcb ? Uint8Array.from(minTcb) : null
+  );
+}
+var cache = /* @__PURE__ */ new Map();
+var CRL_TTL_MS = 60 * 60 * 1e3;
+async function fetchBytes(fetchImpl, url, what, { attempts = 5, sleep: sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)) } = {}) {
+  const hit = cache.get(url);
+  if (hit && (what === "VCEK" || Date.now() - hit.at < CRL_TTL_MS)) return hit.bytes;
+  for (let attempt = 1; ; attempt += 1) {
+    const response = await fetchImpl(url);
+    if (response.ok) {
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      cache.set(url, { bytes, at: Date.now() });
+      return bytes;
+    }
+    if ((response.status === 429 || response.status === 503) && attempt < attempts) {
+      const retryAfter = Number(response.headers?.get?.("retry-after"));
+      await sleep2(Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, 60) * 1e3 : 2e3 * 2 ** (attempt - 1));
+      continue;
+    }
+    throw new Error(`AMD KDS answered ${response.status} for the ${what}: ${url}`);
+  }
+}
+
+// ../attest-wasm/js/ratls.mjs
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var fromHex = (text) => Uint8Array.from(text.match(/../g) ?? [], (pair) => parseInt(pair, 16));
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+function websocketTransport(url, { WebSocketImpl = globalThis.WebSocket } = {}) {
+  const socket = new WebSocketImpl(url);
+  socket.binaryType = "arraybuffer";
+  const opened = new Promise((resolve, reject) => {
+    socket.addEventListener("open", () => resolve(), { once: true });
+    socket.addEventListener("error", () => reject(new Error(`WebSocket to ${url} failed`)), { once: true });
+  });
+  return {
+    opened,
+    send: (bytes) => socket.send(bytes),
+    onData: (callback) => socket.addEventListener("message", (event) => callback(new Uint8Array(event.data))),
+    onClose: (callback) => socket.addEventListener("close", () => callback()),
+    close: () => socket.close()
+  };
+}
+async function openAttestedChannel({ wasm, transport, expectedMeasurements, expectedPolicy, timeoutMs = 3e4 }) {
+  const session = new wasm.RaTlsSession(expectedMeasurements, expectedPolicy == null ? null : String(expectedPolicy));
+  let plaintext = new Uint8Array(0);
+  let failure = null;
+  let closed = false;
+  const waiters = /* @__PURE__ */ new Set();
+  const wake = () => {
+    for (const waiter of waiters) waiter();
+  };
+  const flush = () => {
+    const out = session.takeOutgoing();
+    if (out.length > 0) transport.send(out);
+  };
+  transport.onData((bytes) => {
+    try {
+      session.pushIncoming(bytes);
+      flush();
+      const more = session.isHandshaking() ? new Uint8Array(0) : session.takePlaintext();
+      if (more.length > 0) plaintext = concat(plaintext, more);
+    } catch (error) {
+      failure = error instanceof Error ? error : new Error(String(error));
+      transport.close();
+    }
+    wake();
+  });
+  transport.onClose(() => {
+    closed = true;
+    wake();
+  });
+  const until = (predicate, what) => new Promise((resolve, reject) => {
+    const deadline = setTimeout(() => {
+      waiters.delete(check);
+      reject(new Error(`timed out waiting for ${what}`));
+    }, timeoutMs);
+    const check = () => {
+      if (failure) {
+        clearTimeout(deadline);
+        waiters.delete(check);
+        reject(failure);
+      } else if (predicate()) {
+        clearTimeout(deadline);
+        waiters.delete(check);
+        resolve();
+      } else if (closed) {
+        clearTimeout(deadline);
+        waiters.delete(check);
+        reject(new Error(`the connection closed while waiting for ${what}`));
+      }
+    };
+    waiters.add(check);
+    check();
+  });
+  if (transport.opened) await transport.opened;
+  flush();
+  await until(() => !session.isHandshaking(), "the attested TLS handshake");
+  const request = async (method, path, { headers = {}, body } = {}) => {
+    const payload = body == null ? new Uint8Array(0) : typeof body === "string" ? encoder.encode(body) : body;
+    const lines = [`${method} ${path} HTTP/1.1`, "host: attestation.aleph.invalid", `content-length: ${payload.length}`];
+    for (const [name, value] of Object.entries(headers)) lines.push(`${name}: ${value}`);
+    plaintext = new Uint8Array(0);
+    session.writePlaintext(concat(encoder.encode(`${lines.join("\r\n")}\r
+\r
+`), payload));
+    flush();
+    let response = null;
+    await until(() => (response = parseResponse(plaintext)) !== null, `the answer to ${method} ${path}`);
+    plaintext = new Uint8Array(0);
+    return response;
+  };
+  return {
+    session,
+    request,
+    certReport: session.certReport(),
+    servedPublicKey: session.servedPublicKey(),
+    close: () => {
+      session.close();
+      try {
+        flush();
+      } catch {
+      }
+      transport.close();
+    }
+  };
+}
+function parseResponse(bytes) {
+  const text = decoder.decode(bytes);
+  const end = text.indexOf("\r\n\r\n");
+  if (end < 0) return null;
+  const [statusLine, ...headerLines] = text.slice(0, end).split("\r\n");
+  const status = Number(statusLine.split(" ")[1]);
+  const headers = {};
+  for (const line of headerLines) {
+    const colon = line.indexOf(":");
+    if (colon > 0) headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+  }
+  const head = encoder.encode(text.slice(0, end + 4)).length;
+  const rest = bytes.slice(head);
+  if (headers["transfer-encoding"]?.toLowerCase() === "chunked") {
+    const chunks = [];
+    let offset = 0;
+    for (; ; ) {
+      const lineEnd = decoder.decode(rest.slice(offset)).indexOf("\r\n");
+      if (lineEnd < 0) return null;
+      const size = parseInt(decoder.decode(rest.slice(offset, offset + lineEnd)), 16);
+      offset += lineEnd + 2;
+      if (size === 0) break;
+      if (rest.length < offset + size + 2) return null;
+      chunks.push(rest.slice(offset, offset + size));
+      offset += size + 2;
+    }
+    return { status, headers, body: chunks.reduce(concat, new Uint8Array(0)) };
+  }
+  const length = Number(headers["content-length"] ?? 0);
+  if (rest.length < length) return null;
+  return { status, headers, body: rest.slice(0, length) };
+}
+async function attestGuest({
+  wasm,
+  transport,
+  product,
+  expectedMeasurements,
+  expectedPolicy,
+  minTcb,
+  fetch: fetch2,
+  verify = verifyAttestation,
+  nonce = globalThis.crypto.getRandomValues(new Uint8Array(32)),
+  timeoutMs
+}) {
+  const channel = await openAttestedChannel({ wasm, transport, expectedMeasurements, expectedPolicy, timeoutMs });
+  try {
+    const check = (report) => verify({ wasm, report, product, expectedMeasurements, expectedPolicy, minTcb, fetch: fetch2 });
+    const certVerified = await check(channel.certReport);
+    const response = await channel.request("GET", `/.well-known/attestation?nonce=${hex(nonce)}`);
+    if (response.status !== 200) throw new Error(`the guest answered ${response.status} to the freshness challenge`);
+    const dto = JSON.parse(decoder.decode(response.body));
+    if (dto.tee_type !== "sev-snp") throw new Error(`the fresh report is ${dto.tee_type}, not sev-snp`);
+    const freshReport = fromHex(String(dto.data ?? ""));
+    const freshVerified = await check(freshReport);
+    wasm.verifyFreshBinding(freshReport, channel.servedPublicKey, nonce);
+    return { channel, servedPublicKey: channel.servedPublicKey, certVerified, freshVerified };
+  } catch (error) {
+    channel.close();
+    throw error;
+  }
+}
+function canonicalSecretsJson(secrets) {
+  const sorted = {};
+  for (const key of Object.keys(secrets).sort()) sorted[key] = String(secrets[key]);
+  return JSON.stringify(sorted);
+}
+async function injectSecrets({ wasm, attested, secrets, sign }) {
+  const canonical = canonicalSecretsJson(secrets);
+  const payload = wasm.injectSecretPayload(attested.servedPublicKey, canonical);
+  const signature = await sign(payload);
+  const response = await attested.channel.request("POST", "/confidential/inject-secret", {
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ secrets: JSON.parse(canonical), signature })
+  });
+  const text = decoder.decode(response.body);
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(`the guest refused the secrets (${response.status}): ${text}`);
+  }
+  return JSON.parse(text);
+}
+
+// ../attest-wasm/js/runtime.mjs
+var VM_IMAGES_ADDRESS = "0xFba561a84A537fCaa567bb7A2257e7142701ae2A";
+var DEFAULT_SNP_POLICY = 196608;
+var DEFAULT_API = "https://api2.aleph.im";
+var DEFAULT_IPFS = "https://ipfs.aleph.im/ipfs";
+var hex2 = (bytes) => Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+async function resolveInstanceRuntime({ apiHost = DEFAULT_API, name, fetch: fetchImpl = globalThis.fetch } = {}) {
+  const response = await fetchImpl(`${apiHost}/api/v0/aggregates/${VM_IMAGES_ADDRESS}.json?keys=vm-images`);
+  if (!response.ok) throw new Error(`vm-images aggregate answered ${response.status}`);
+  const images = (await response.json()).data?.["vm-images"] ?? {};
+  const key = name ?? images.defaults?.instance_runtime;
+  const entry = images.instance_runtimes?.[key];
+  if (!entry?.hash) throw new Error(`no instance runtime ${JSON.stringify(key)} in vm-images`);
+  return { name: key, itemHash: entry.hash, deprecated: entry.deprecated === true };
+}
+async function fetchStoreBytes({ apiHost = DEFAULT_API, ipfsGateway = DEFAULT_IPFS, itemHash, fetch: fetchImpl = globalThis.fetch }) {
+  const message = await (await fetchImpl(`${apiHost}/api/v0/messages/${itemHash}`)).json();
+  const content = message.message?.content ?? message.content;
+  if ((message.message?.type ?? message.type) !== "STORE" || !content?.item_hash) throw new Error(`${itemHash} is not a STORE message`);
+  const url = content.item_type === "ipfs" ? `${ipfsGateway}/${content.item_hash}` : `${apiHost}/api/v0/storage/raw/${content.item_hash}`;
+  const response = await fetchImpl(url);
+  if (!response.ok) throw new Error(`fetching ${itemHash} answered ${response.status}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+function untar(bytes) {
+  const files = /* @__PURE__ */ new Map();
+  const decoder2 = new TextDecoder();
+  for (let offset = 0; offset + 512 <= bytes.length; ) {
+    const header = bytes.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const field = (start2, length) => decoder2.decode(header.subarray(start2, start2 + length)).replace(/\0.*$/s, "").trim();
+    const prefix = field(345, 155);
+    const name = (prefix ? `${prefix}/` : "") + field(0, 100);
+    const size = parseInt(field(124, 12) || "0", 8);
+    const type = field(156, 1);
+    const start = offset + 512;
+    if (type === "" || type === "0") files.set(name.replace(/^\.\//, ""), bytes.subarray(start, start + size));
+    offset = start + Math.ceil(size / 512) * 512;
+  }
+  return files;
+}
+async function gunzip(bytes) {
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function fetchInstanceRuntime({ itemHash, apiHost, ipfsGateway, fetch: fetch2 }) {
+  const manifest = JSON.parse(new TextDecoder().decode(await fetchStoreBytes({ apiHost, ipfsGateway, itemHash, fetch: fetch2 })));
+  if (manifest.format !== "aleph-instance-runtime" || manifest.platform !== "sev_snp") {
+    throw new Error(`${itemHash} is not an SEV-SNP instance runtime manifest`);
+  }
+  const bundle = await fetchStoreBytes({ apiHost, ipfsGateway, itemHash: manifest.bundle.ref, fetch: fetch2 });
+  const digest = hex2(await globalThis.crypto.subtle.digest("SHA-256", bundle));
+  if (digest !== manifest.bundle.sha256 || manifest.bundle.size && bundle.length !== manifest.bundle.size) {
+    throw new Error(`the runtime bundle does not match its manifest (sha256 ${digest})`);
+  }
+  const files = untar(await gunzip(bundle));
+  const member = (role) => {
+    const data = files.get(manifest.bundle.members[role]);
+    if (!data) throw new Error(`the runtime bundle has no ${role} (${manifest.bundle.members[role]})`);
+    return data;
+  };
+  return { itemHash, manifest, ovmf: member("ovmf"), kernel: member("kernel"), initrd: member("initrd") };
+}
+function trustedExecution({ wasm, runtime, owner, vcpus, policy = DEFAULT_SNP_POLICY }) {
+  const cmdline = wasm.instanceCmdline(runtime.manifest.boot.cmdline_template, owner);
+  const measurements = wasm.launchMeasurements(runtime.ovmf, runtime.kernel, runtime.initrd, cmdline, vcpus, runtime.manifest.boot.cpu_models);
+  return {
+    mode: "sev_snp",
+    policy,
+    runtime: runtime.itemHash,
+    measurements: measurements.map(({ vcpuType, launch }) => ({ platform: "sev_snp", registers: { launch }, vcpu_type: vcpuType }))
+  };
+}
+
+// ../attest-wasm/js/instance.mjs
+var DEFAULT_API2 = "https://api2.aleph.im";
+async function confidentialTrustedExecution({
+  wasm,
+  owner,
+  vcpus,
+  policy = DEFAULT_SNP_POLICY,
+  runtimeName,
+  apiHost = DEFAULT_API2,
+  fetch: fetch2,
+  onProgress = () => {
+  }
+}) {
+  onProgress({ phase: "runtime", detail: "Resolving the SEV-SNP runtime" });
+  const resolved = await resolveInstanceRuntime({ apiHost, name: runtimeName, fetch: fetch2 });
+  onProgress({ phase: "bundle", detail: `Downloading runtime ${resolved.name}` });
+  const runtime = await fetchInstanceRuntime({ itemHash: resolved.itemHash, apiHost, fetch: fetch2 });
+  onProgress({ phase: "measure", detail: "Computing the launch measurements" });
+  return trustedExecution({ wasm, runtime, owner, vcpus, policy });
+}
+function pinsOf(tee) {
+  const expectedMeasurements = (tee?.measurements ?? []).filter((entry) => entry?.platform === "sev_snp" && typeof entry?.registers?.launch === "string").map((entry) => entry.registers.launch);
+  if (expectedMeasurements.length === 0) throw new Error("the trusted_execution block pins no SEV-SNP measurements");
+  return { expectedMeasurements, expectedPolicy: tee.policy };
+}
+var NOT_YET = /closed|timed out|Bad Gateway|WebSocket to .* failed|ECONNREFUSED|ECONNRESET/i;
+var VERDICT = /rejected|bind|measurement|policy|floor|KDS answered 4|signature|refused the secrets/i;
+async function unlockInstance({
+  wasm,
+  relayUrl,
+  crnHash,
+  instanceItemHash,
+  trustedExecution: tee,
+  passphrase,
+  secrets = {},
+  sign,
+  attempts = 12,
+  delayMs = 1e4,
+  sleep: sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  transport = (url) => websocketTransport(url),
+  verify,
+  fetch: fetch2,
+  onProgress = () => {
+  }
+}) {
+  if (!passphrase) throw new Error("unlocking needs the passphrase of the encrypted rootfs");
+  if ("luks_passphrase" in secrets) throw new Error("pass the passphrase as passphrase, not in secrets");
+  const { expectedMeasurements, expectedPolicy } = pinsOf(tee);
+  const url = `${relayUrl}${relayUrl.includes("?") ? "&" : "?"}crn=${crnHash}&vm=${instanceItemHash}`;
+  let attested = null;
+  for (let attempt = 1; !attested; attempt += 1) {
+    onProgress({ phase: "attest", detail: `Attesting the guest (${attempt}/${attempts})` });
+    try {
+      attested = await attestGuest({
+        wasm,
+        transport: transport(url),
+        expectedMeasurements,
+        expectedPolicy,
+        fetch: fetch2,
+        ...verify ? { verify } : {}
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (VERDICT.test(message) || !NOT_YET.test(message) || attempt >= attempts) throw error;
+      onProgress({ phase: "wait", detail: `The guest is not answering yet: ${message}` });
+      await sleep2(delayMs);
+    }
+  }
+  try {
+    onProgress({ phase: "unlock", detail: "Sign the unlock in your wallet" });
+    const injected = await injectSecrets({ wasm, attested, secrets: { ...secrets, luks_passphrase: passphrase }, sign });
+    return {
+      injected: injected.injected ?? [],
+      measurement: attested.freshVerified.measurement,
+      policy: attested.freshVerified.policy,
+      launchTcb: attested.freshVerified.launchTcb
+    };
+  } finally {
+    attested.channel.close();
+  }
+}
+
+// src/shared/wallet-controller.ts
+function toChecksumAddress(address) {
+  try {
+    return getAddress(address);
+  } catch {
+    throw new Error("Invalid EVM address.");
+  }
+}
+async function connectWallet2(provider = getEthereumProvider()) {
+  return connectWallet(provider, {
+    normaliseAddress: toChecksumAddress
+  });
+}
+
 // ../core/src/constants.ts
 var DEFAULT_ALEPH_CHANNEL = "ALEPH-CLOUDSOLUTIONS";
 
 // ../core/src/manifests.ts
 var DEFAULT_ALEPH_API_HOST2 = "https://api.aleph.im";
 
+// ../core/src/confidential.ts
+var MIN_CONFIDENTIAL_ALEPH_VM_VERSION = "2.1.2";
+var SNP_POLICY_RESERVED_BIT_17 = 131072;
+function versionParts(value) {
+  const match = /^v?(\d+)\.(\d+)(?:\.(\d+))?/.exec(value.trim());
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)];
+}
+function compareAlephVmVersions(left, right) {
+  const a = versionParts(left);
+  const b = versionParts(right);
+  if (!a || !b) return null;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return 0;
+}
+function supportsSevSnp(crn) {
+  return Boolean(crn.tee?.sev_snp) || (crn.cpu_features ?? []).includes("sev_snp");
+}
+function supportsSev(crn) {
+  if (supportsSevSnp(crn)) return true;
+  if ((crn.cpu_features ?? []).includes("sev")) return true;
+  return crn.confidential_support === true;
+}
+function isConfidentialCrn(crn, requirement = {}) {
+  const mode = requirement.mode ?? "sev_snp";
+  if (mode === "sev_snp" ? !supportsSevSnp(crn) : !supportsSev(crn)) return false;
+  if (!crn.version) return false;
+  const comparison = compareAlephVmVersions(crn.version, requirement.minVersion ?? MIN_CONFIDENTIAL_ALEPH_VM_VERSION);
+  return comparison !== null && comparison >= 0;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : null;
+}
+async function fetchJson(fetch2, url) {
+  try {
+    const response = await fetch2(url, { cache: "no-cache" });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  }
+}
+async function probeCrnTee(crn, options) {
+  const address = crn.address ? String(crn.address).replace(/\/+$/, "") : "";
+  if (!address) return crn;
+  const [usage, config] = await Promise.all([
+    fetchJson(options.fetch, `${address}/about/usage/system`),
+    fetchJson(options.fetch, `${address}/status/config`)
+  ]);
+  const enriched = { ...crn };
+  const properties = usage?.properties;
+  const features = asStringArray(properties?.cpu?.features);
+  if (features) enriched.cpu_features = features;
+  if (properties && "tee" in properties) {
+    enriched.tee = properties.tee && typeof properties.tee === "object" ? properties.tee : null;
+  }
+  const version = config?.version;
+  if (typeof version === "string" && version) enriched.version = version;
+  return enriched;
+}
+async function enrichCrnsWithTee(crns, options) {
+  const result = [...crns];
+  const pending = result.map((crn, index) => ({ crn, index })).filter(({ crn }) => !crn.version || crn.cpu_features == null && crn.tee == null);
+  const concurrency = Math.max(1, Number(options.concurrency) || 8);
+  for (let start = 0; start < pending.length; start += concurrency) {
+    const batch = pending.slice(start, start + concurrency);
+    const probed = await Promise.all(batch.map(({ crn }) => probeCrnTee(crn, { fetch: options.fetch })));
+    batch.forEach(({ index }, i) => {
+      result[index] = probed[i];
+    });
+  }
+  return result;
+}
+var HEX_HASH = /^[a-fA-F0-9]{64}$/;
+function assertValidTrustedExecution(value) {
+  const mode = value.mode ?? "sev";
+  if (mode === "sev") {
+    if (!value.firmware || !HEX_HASH.test(value.firmware)) {
+      throw new Error("trusted_execution: legacy SEV needs a 64-character firmware item hash.");
+    }
+    if (value.runtime || value.measurements) {
+      throw new Error("trusted_execution: runtime and measurements belong to measured modes, not legacy SEV.");
+    }
+    return;
+  }
+  if (value.firmware) {
+    throw new Error(`trusted_execution: firmware is for legacy SEV only, not ${mode}.`);
+  }
+  if (!value.runtime || !HEX_HASH.test(value.runtime)) {
+    throw new Error(`trusted_execution: ${mode} needs the runtime bundle's 64-character item hash.`);
+  }
+  const measurements = value.measurements ?? [];
+  if (measurements.length === 0 || measurements.some((m) => m.platform !== mode || Object.keys(m.registers ?? {}).length === 0)) {
+    throw new Error(`trusted_execution: ${mode} needs expected measurements for platform ${mode}.`);
+  }
+  if (mode === "sev_snp" && value.policy !== void 0 && (value.policy & SNP_POLICY_RESERVED_BIT_17) === 0) {
+    throw new Error("trusted_execution: an SEV-SNP policy must set the reserved bit 17 (e.g. 0x30000).");
+  }
+  if (mode === "tdx" && value.policy !== void 0) {
+    throw new Error("trusted_execution: tdx has no host-chosen policy; leave it unset.");
+  }
+  if (value.attestation_port !== void 0 && !(Number.isInteger(value.attestation_port) && value.attestation_port > 0 && value.attestation_port < 65536)) {
+    throw new Error("trusted_execution: attestation_port must be a TCP port.");
+  }
+}
+
 // ../core/src/crns.ts
 var DEFAULT_CRN_LIST_URL2 = "https://crns-list.aleph.sh/crns.json";
 var DEFAULT_CRN_AGGREGATE_ADDRESS2 = "0xa1B3bb7d2332383D96b7796B908fB7f7F3c2Be10";
@@ -1165,8 +1696,9 @@ function scoreSortedCrns(crns) {
   });
 }
 function filterDeployableCrns(crns, options = {}) {
+  const confidential = options.confidential;
   return scoreSortedCrns(
-    compatibleCrns(crns, options.excludedHashes).filter((crn) => hasCrnCapacity(crn, options.spec))
+    compatibleCrns(crns, options.excludedHashes).filter((crn) => hasCrnCapacity(crn, options.spec)).filter((crn) => !confidential || isConfidentialCrn(crn, confidential))
   );
 }
 async function fetchCrnsFromList2(options) {
@@ -1221,6 +1753,8 @@ function mapResourceNodesToCrns2(resourceNodes) {
     if (name) record.name = name;
     const score = aggregateScore(node);
     if (score != null) record.score = score;
+    const owner = asString2(node.owner);
+    if (owner) record.owner = owner;
     return record;
   });
 }
@@ -2364,6 +2898,9 @@ function createInstanceContent(args) {
   if (!args.rootfsItemHash || !/^[a-fA-F0-9]{64}$/.test(args.rootfsItemHash)) {
     throw new Error("rootfsItemHash must be a 64-character Aleph item hash.");
   }
+  if (args.trustedExecution) {
+    assertValidTrustedExecution(args.trustedExecution);
+  }
   return {
     address: args.address,
     time: args.now ?? Date.now() / 1e3,
@@ -2375,7 +2912,8 @@ function createInstanceContent(args) {
       aleph_api: true,
       hypervisor: "qemu",
       reproducible: false,
-      shared_cache: false
+      shared_cache: false,
+      ...args.trustedExecution ? { trusted_execution: args.trustedExecution } : {}
     },
     resources: {
       vcpus: Number(args.vcpus),
@@ -3833,6 +4371,47 @@ function createDeploymentProgressEmitter() {
   };
 }
 
+// src/shared/unverifiable-crns.ts
+var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var remembered = /* @__PURE__ */ new Map();
+function isUnverifiableNodeError(message) {
+  return /AMD KDS answered 404/i.test(message);
+}
+function load(storageKey, now) {
+  if (!storageKey) return;
+  try {
+    const stored = JSON.parse(globalThis.localStorage?.getItem(storageKey) ?? "{}");
+    for (const [hash, until] of Object.entries(stored)) {
+      if (/^[0-9a-f]{64}$/.test(hash) && typeof until === "number" && until > now) {
+        remembered.set(hash, Math.max(until, remembered.get(hash) ?? 0));
+      }
+    }
+  } catch {
+  }
+}
+function unverifiableCrnHashes(storageKey, now = Date.now()) {
+  load(storageKey, now);
+  for (const [hash, until] of remembered) if (until <= now) remembered.delete(hash);
+  return new Set(remembered.keys());
+}
+function rememberUnverifiableCrn(hash, storageKey, now = Date.now()) {
+  if (!/^[0-9a-f]{64}$/.test(hash)) return;
+  load(storageKey, now);
+  remembered.set(hash, now + TTL_MS);
+  if (!storageKey) return;
+  try {
+    globalThis.localStorage?.setItem(storageKey, JSON.stringify(Object.fromEntries(remembered)));
+  } catch {
+  }
+}
+function demoteUnverifiableCrns(crns, refused, pinned) {
+  const demoted = (crn) => refused.has(crn.hash) && crn.hash !== pinned;
+  return [...crns.filter((crn) => !demoted(crn)), ...crns.filter(demoted)];
+}
+function forgetUnverifiableCrns() {
+  remembered.clear();
+}
+
 // ../shared-types/src/ucan-store-bootstrap.ts
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -4139,6 +4718,9 @@ function defaultState(props = {}) {
     instanceName: props.instanceName ?? DEFAULT_INSTANCE_NAME,
     ucanStoreBootstrap: defaultUcanStoreBootstrapInput(props),
     tierId: DEFAULT_TIER_ID,
+    confidential: props.confidential ?? false,
+    confidentialStartAvailable: Boolean(props.confidentialStart),
+    confidentialPassphrase: "",
     showAdvanced: false,
     showInstances: props.showInstances ?? true,
     showPasteManifest: Boolean(props.manifestJson?.trim()),
@@ -4551,7 +5133,25 @@ function compatibleCrnsForTier(crns, state) {
     state.pricingSummary.pricing,
     state.pricingSummary.tier
   );
-  return filterDeployableCrns(crns, { spec });
+  return filterDeployableCrns(crns, {
+    spec,
+    confidential: state.confidential ? {} : null
+  });
+}
+var CONFIDENTIAL_PROBE_LIMIT = 80;
+async function confidentialCandidates(crns) {
+  const flagged = crns.filter(
+    (crn) => crn.confidential_support === true || (crn.cpu_features ?? []).some((feature) => feature.startsWith("sev"))
+  );
+  const score = (crn) => Number(crn.score ?? Number.NEGATIVE_INFINITY);
+  const pool = flagged.length > 0 ? flagged : [...crns].sort((left, right) => score(right) - score(left)).slice(0, CONFIDENTIAL_PROBE_LIMIT);
+  return enrichCrnsWithTee(pool, {
+    fetch: (url, init) => fetchWithTimeout(url, init, 8e3)
+  });
+}
+function shortOperator(address) {
+  if (!address) return null;
+  return address.length > 12 ? `${address.slice(0, 6)}\u2026${address.slice(-4)}` : address;
 }
 var UI_DEPLOY_WAIT_ATTEMPTS = 60;
 var UI_DEPLOY_WAIT_DELAY_MS = 5e3;
@@ -5625,8 +6225,8 @@ var SponsorRelayController = class {
     });
   }
   mergeRememberedRuntimeDetails(itemHash, details) {
-    const remembered = this.runtimeDetailsByHash.get(itemHash);
-    if (!remembered) {
+    const remembered2 = this.runtimeDetailsByHash.get(itemHash);
+    if (!remembered2) {
       return details;
     }
     if (details.messageStatus === "processed" && hasUsableRuntime(details)) {
@@ -5635,13 +6235,13 @@ var SponsorRelayController = class {
     this.trace("runtime:retain-known-details", {
       itemHash,
       currentStatus: details.messageStatus,
-      rememberedStatus: remembered.messageStatus,
+      rememberedStatus: remembered2.messageStatus,
       currentHasRuntime: hasUsableRuntime(details)
     });
     return {
       ...details,
-      ...remembered,
-      error: details.error ?? remembered.error
+      ...remembered2,
+      error: details.error ?? remembered2.error
     };
   }
   async init() {
@@ -5732,7 +6332,10 @@ var SponsorRelayController = class {
     const crnOptions = compatibleList.slice(0, 15).map((crn) => ({
       hash: crn.hash,
       name: crn.name ?? null,
-      score: typeof crn.score === "number" ? crn.score : null
+      score: typeof crn.score === "number" ? crn.score : null,
+      country: crn.country_code ?? null,
+      version: crn.version ?? null,
+      operator: shortOperator(crn.owner ?? crn.payment_receiver_address)
     }));
     this.patch({
       crnOptions,
@@ -5749,6 +6352,27 @@ var SponsorRelayController = class {
       selectedCrn
     });
   }
+  /**
+   * Switch between a normal and a confidential VM. Pricing and the node list
+   * differ between the two, so both are loaded again.
+   */
+  async setConfidential(confidential) {
+    if (confidential === this.state.confidential) return;
+    this.patch({
+      confidential,
+      crnPinnedByUser: false,
+      selectedCrn: null,
+      crnOptions: []
+    });
+    await this.refresh();
+  }
+  /**
+   * The encrypted rootfs's passphrase for a confidential start. Kept in
+   * memory only until the unlock, then cleared; never persisted.
+   */
+  setConfidentialPassphrase(passphrase) {
+    this.patch({ confidentialPassphrase: passphrase });
+  }
   /** Pin a specific CRN as the first deploy attempt (null = automatic). */
   selectCrn(hash) {
     if (!hash) {
@@ -5779,7 +6403,7 @@ var SponsorRelayController = class {
       statusText: "Connecting MetaMask"
     });
     try {
-      const wallet = await connectWallet();
+      const wallet = await connectWallet2();
       this.patch({
         wallet,
         busy: { connectingWallet: false },
@@ -5799,7 +6423,7 @@ var SponsorRelayController = class {
       return;
     }
     try {
-      const wallet = await connectWallet();
+      const wallet = await connectWallet2();
       this.patch({ wallet });
       await this.refresh();
     } catch {
@@ -5827,10 +6451,15 @@ var SponsorRelayController = class {
     });
     try {
       const [pricingSummary, crnList] = await Promise.all([
-        fetchInstancePricing(this.client.apiHost),
+        fetchInstancePricing(
+          this.client.apiHost,
+          void 0,
+          this.state.confidential ? "instance_confidential" : "instance"
+        ),
         this.client.fetchCrnsWithSource(crnSourcePreference(this.props))
       ]);
-      const { crns, source: crnSource } = crnList;
+      const { source: crnSource } = crnList;
+      const crns = this.state.confidential ? await confidentialCandidates(crnList.crns) : crnList.crns;
       if (crnList.listError) {
         this.trace("crns:fallback", {
           source: crnSource,
@@ -6023,6 +6652,19 @@ var SponsorRelayController = class {
       this.patch({ errorText: "Connect MetaMask before deploying." });
       return;
     }
+    const confidentialStart = this.state.confidential ? this.props.confidentialStart ?? null : null;
+    if (this.state.confidential) {
+      if (!confidentialStart) {
+        this.patch({
+          errorText: "This site has not set up confidential starts (confidentialStart: encrypted rootfs, attest relay, attestation WASM)."
+        });
+        return;
+      }
+      if (!this.state.confidentialPassphrase) {
+        this.patch({ errorText: "Enter the passphrase of the encrypted rootfs to start a confidential VM." });
+        return;
+      }
+    }
     if (!this.state.manifest || this.state.rootfsHealth.tone !== "ok" || !this.state.pricingSummary.pricing || !this.state.pricingSummary.tier) {
       this.patch({
         errorText: this.state.rootfsHealth.tone === "error" ? `Cannot deploy: ${this.state.rootfsHealth.detail ?? this.state.rootfsHealth.label}` : "Manifest, rootfs, and pricing must be ready before deploying."
@@ -6065,10 +6707,15 @@ var SponsorRelayController = class {
         }
       });
       const preferredCrnHash = this.state.selectedCrn?.hash ?? null;
-      const rankedCrns = [
+      const pinnedFirst = [
         ...compatibleCrns2.filter((crn) => crn.hash === preferredCrnHash),
         ...compatibleCrns2.filter((crn) => crn.hash !== preferredCrnHash)
-      ].slice(0, 5);
+      ];
+      const rankedCrns = (this.state.confidential ? demoteUnverifiableCrns(
+        pinnedFirst,
+        unverifiableCrnHashes(this.props.confidentialStart?.refusedNodesStorageKey),
+        this.state.crnPinnedByUser ? preferredCrnHash : null
+      ) : pinnedFirst).slice(0, 5);
       const orderedCrns = this.state.crnSource === "aggregate" ? await filterReachableCrns(rankedCrns, {
         limit: rankedCrns.length,
         onDiagnostic: (message) => this.trace("crns:probe", { message })
@@ -6085,6 +6732,39 @@ var SponsorRelayController = class {
           "No compatible CRN is currently available for this tier."
         );
       }
+      let attestWasm = null;
+      let trustedExecution2 = null;
+      if (confidentialStart) {
+        this.emitProgress({
+          stage: "preparing-confidential",
+          label: "Preparing the confidential launch",
+          progress: 10,
+          status: "info",
+          detail: "Loading the attestation module."
+        });
+        attestWasm = await confidentialStart.loadWasm();
+        trustedExecution2 = await confidentialTrustedExecution({
+          wasm: attestWasm,
+          owner: this.state.wallet.address,
+          vcpus: spec.vcpus,
+          runtimeName: confidentialStart.runtimeName,
+          apiHost: this.client.apiHost,
+          onProgress: ({ detail }) => this.emitProgress({
+            stage: "preparing-confidential",
+            label: "Preparing the confidential launch",
+            progress: 12,
+            status: "info",
+            detail
+          })
+        });
+        this.trace("deploy:confidential-measurements", trustedExecution2);
+      }
+      const rootfsItemHash = confidentialStart?.rootfsItemHash ?? this.state.manifest.rootfsItemHash;
+      const rootfsSizeMiB = Math.max(
+        confidentialStart?.rootfsSizeMiB ?? 0,
+        this.state.manifest.rootfsSizeMiB,
+        spec.diskMiB
+      );
       const attemptErrors = [];
       let lastError = null;
       for (const [candidateIndex, candidateCrn] of orderedCrns.entries()) {
@@ -6112,15 +6792,13 @@ var SponsorRelayController = class {
             address: this.state.wallet.address,
             name: this.state.instanceName.trim(),
             sshPublicKey,
-            rootfsItemHash: this.state.manifest.rootfsItemHash,
-            rootfsSizeMiB: Math.max(
-              this.state.manifest.rootfsSizeMiB,
-              spec.diskMiB
-            ),
+            rootfsItemHash,
+            rootfsSizeMiB,
             vcpus: spec.vcpus,
             memoryMiB: spec.memoryMiB,
             rootfsVersion: this.state.manifest.version,
-            crnHash: candidateCrn.hash
+            crnHash: candidateCrn.hash,
+            trustedExecution: trustedExecution2 ?? void 0
           });
           const result = await deployInstance({
             sender: this.state.wallet.address,
@@ -6146,7 +6824,7 @@ var SponsorRelayController = class {
           });
           this.lastCompletedDeploymentHash = null;
           const inspection = await waitForDeploymentResult2(result.itemHash, {
-            rootfsRef: this.state.manifest.rootfsItemHash,
+            rootfsRef: rootfsItemHash,
             apiHost: this.client.apiHost,
             fetch: (url, init) => fetch(url, init),
             attempts: UI_DEPLOY_WAIT_ATTEMPTS,
@@ -6236,6 +6914,39 @@ var SponsorRelayController = class {
               );
             }
           }
+          if (confidentialStart && attestWasm && trustedExecution2) {
+            const unlocked = await unlockInstance({
+              wasm: attestWasm,
+              relayUrl: confidentialStart.relayUrl,
+              crnHash: candidateCrn.hash,
+              instanceItemHash: result.itemHash,
+              trustedExecution: trustedExecution2,
+              passphrase: this.state.confidentialPassphrase,
+              // The rootfs ignores the INSTANCE's authorized_keys (no
+              // cloud-init), so the key, with the bootstrap token, comes here.
+              secrets: { authorized_keys: `${sshPublicKey}
+` },
+              sign: (payload) => personalSign(this.state.wallet.address, payload),
+              onProgress: ({ phase, detail }) => this.emitProgress({
+                stage: phase === "unlock" ? "unlocking-guest" : "attesting-guest",
+                label: phase === "unlock" ? "Unlocking the confidential VM" : "Attesting the confidential VM",
+                progress: phase === "unlock" ? 89 : 87,
+                status: "info",
+                itemHash: result.itemHash,
+                detail
+              })
+            });
+            this.patch({ confidentialPassphrase: "" });
+            this.trace("deploy:confidential-unlocked", unlocked);
+            this.emitProgress({
+              stage: "unlocking-guest",
+              label: "Confidential VM attested and unlocked",
+              progress: 89,
+              status: "success",
+              itemHash: result.itemHash,
+              detail: `Measurement ${unlocked.measurement.slice(0, 16)}\u2026, policy ${unlocked.policy}, TCB bootloader ${unlocked.launchTcb.bootloader} snp ${unlocked.launchTcb.snp} microcode ${unlocked.launchTcb.microcode}.`
+            });
+          }
           this.emitProgress({
             stage: "deployment-confirmed",
             label: "Waiting for runtime",
@@ -6344,6 +7055,9 @@ var SponsorRelayController = class {
           const attemptLabel = crnDisplayName;
           const failedDueToInvalidIpv6 = /not globally routable|public guest IPv6/i.test(lastError.message);
           attemptErrors.push(`${attemptLabel}: ${lastError.message}`);
+          if (this.state.confidential && isUnverifiableNodeError(lastError.message)) {
+            rememberUnverifiableCrn(candidateCrn.hash, confidentialStart?.refusedNodesStorageKey);
+          }
           this.trace("deploy:crn-attempt-error", {
             crnHash: candidateCrn.hash,
             crnName: candidateCrn.name,
@@ -6576,6 +7290,7 @@ var SponsorRelayController = class {
         error
       });
       this.patch({
+        confidentialPassphrase: "",
         busy: { deploying: false },
         errorText: message,
         statusText: "Deployment failed"
@@ -6872,27 +7587,33 @@ export {
   anchorPanelToLauncher,
   buildSshCommand,
   clampToViewport,
-  connectWallet,
+  connectWallet2 as connectWallet,
   createDeploymentProgressEmitter,
   createSponsorRelayController,
+  demoteUnverifiableCrns,
   deploymentFailureMessage,
   describeRequest,
   describeThrown,
   dragExceedsThreshold,
+  forgetUnverifiableCrns,
+  formatCrnOptionLabel,
   formatDateTime,
   formatNumber,
   formatTierSpecLabel,
   getEthereumProvider,
+  isUnverifiableNodeError,
   joinMappedPorts,
   joinRequiredPortForwards,
   parseInstanceAddressPayload,
   personalSign,
   readStoredPosition,
+  rememberUnverifiableCrn,
   resolveCornerPlacement,
   resolveManifestSource,
   rootfsHealth,
   shortHash,
   toChecksumAddress,
+  unverifiableCrnHashes,
   watchWallet,
   writeStoredPosition
 };