@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/sealed/index.d.ts

@@ -1,7 +1,7 @@
-export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createAttestedSealedFetch, createSealedFetch, fetchAttestedTransportKey, transportKeyBinding, } from './sealed.js';
-export type { AttestedSealedFetchOptions, SealedFetchOptions, VerifyTransportQuote } from './sealed.js';
+export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createSealedFetch, transportKeyBinding, } from './sealed.js';
+export type { SealedFetchOptions, VerifyTransportQuote } from './sealed.js';
 export { PRODUCTION_PROFILE, createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
 export type { DcapCollateral, DcapVerifiedReport, DcapVerify, PublishedMrtds, QuoteVerifier, QuoteVerifierOptions, TrustedMeasurements, TrustedProfileOptions, } from './verify.js';
-export { DEFAULT_RELEASE_MIRROR, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseSealedFetch, createSignedReleaseVerifier, fetchNodeRelease, fetchNodeReleaseVersion, nodeReleaseVersionFromImage, trustSignedRelease, verifySignedNodeRelease, } from './release.js';
-export type { SignedNodeRelease, SignedReleaseSealedFetchOptions, SignedReleaseVerifierOptions, TrustSignedReleaseOptions, VerifySignedNodeReleaseOptions, } from './release.js';
+export { DEFAULT_RELEASE_MIRROR, GITHUB_RELEASES, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseVerifier, fetchGithubNodeRelease, fetchNodeRelease, trustSignedRelease, verifySignedNodeRelease, } from './release.js';
+export type { SignedNodeRelease, SignedReleaseVerifierOptions, TrustSignedReleaseOptions, VerifySignedNodeReleaseOptions, } from './release.js';
 export type { SignerIdentity } from './sigstore.js';

package/dist/sealed/index.js

@@ -1,3 +1,3 @@
-export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createAttestedSealedFetch, createSealedFetch, fetchAttestedTransportKey, transportKeyBinding, } from './sealed.js';
+export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createSealedFetch, transportKeyBinding, } from './sealed.js';
 export { PRODUCTION_PROFILE, createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
-export { DEFAULT_RELEASE_MIRROR, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseSealedFetch, createSignedReleaseVerifier, fetchNodeRelease, fetchNodeReleaseVersion, nodeReleaseVersionFromImage, trustSignedRelease, verifySignedNodeRelease, } from './release.js';
+export { DEFAULT_RELEASE_MIRROR, GITHUB_RELEASES, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseVerifier, fetchGithubNodeRelease, fetchNodeRelease, trustSignedRelease, verifySignedNodeRelease, } from './release.js';

package/dist/sealed/release.d.ts

@@ -21,7 +21,7 @@
  * - the minimum release you pass, below which no release is accepted.
  *
  * What is not: the transport, the server that serves the release, and the
- * relay's choice of release. A relay can present any genuinely signed release
+ * node's choice of release. A node can present any genuinely signed release
  * at or above the minimum, and no other; its quote must then match that
  * release's measurements exactly, so it cannot claim one release and run
  * another.
@@ -86,25 +86,19 @@ export declare function verifySignedNodeRelease(publishedMrtds: string | Uint8Ar
 export declare function fetchNodeRelease(url: string, options?: {
     fetch?: typeof fetch;
 }): Promise<SignedNodeRelease>;
+/** Where mero-tee publishes its releases' assets, as core's `calimero-tee-release` fetches them. */
+export declare const GITHUB_RELEASES = "https://github.com/calimero-network/mero-tee/releases/download";
 /**
- * The release a mero-tee node image was built from, read from its name, e.g.
- * `merotee-ubuntu-questing-25-10-locked-read-only-2-3-87` is `2.3.87`. Throws
- * for any other name, including the suffixed images of unreleased builds.
+ * Node release `version` straight from its GitHub release (`mero-tee-v{version}`):
+ * `published-mrtds.json` and its cosign bundle, the files core's Rust client
+ * verifies. Only fetched: verify it with {@link trustSignedRelease}. GitHub's
+ * downloads send no CORS headers, so in a browser use a mirror
+ * ({@link cloudNodeReleaseUrl}) instead.
  */
-export declare function nodeReleaseVersionFromImage(osImage: string): string;
-/**
- * The release the TEE node at `baseUrl` says it runs, from the image name its
- * `GET /admin-api/tee/info` reports. The node's own claim, and not trusted:
- * it only picks which signed release to fetch, and the quote must then match
- * that release's measurements.
- *
- * `/tee/info` is read in the clear, before any session exists. A node that
- * requires sealing serves it unsealed from core#4196 on; an older one refuses
- * it with `403 sealed_required`, and then this throws saying so.
- */
-export declare function fetchNodeReleaseVersion(baseUrl: string, options?: {
+export declare function fetchGithubNodeRelease(version: string, options?: {
     fetch?: typeof fetch;
-}): Promise<string>;
+    base?: string;
+}): Promise<SignedNodeRelease>;
 /** Where the cloud at `cloudUrl` (e.g. `https://cloud.calimero.network`) mirrors node release `version`. */
 export declare function cloudNodeReleaseUrl(cloudUrl: string, version: string): string;
 export interface TrustSignedReleaseOptions extends TrustedProfileOptions {
@@ -112,7 +106,7 @@ export interface TrustSignedReleaseOptions extends TrustedProfileOptions {
     release: SignedNodeRelease;
     /**
      * The oldest release accepted, e.g. `2.3.87`. Required: every release ever
-     * signed stays validly signed, so without a floor a relay could present an
+     * signed stays validly signed, so without a floor a node could present an
      * old release, with a flaw since fixed, and a quote from that old image
      * would pass. Raise it when a release must no longer be trusted.
      */
@@ -129,7 +123,7 @@ export interface TrustSignedReleaseOptions extends TrustedProfileOptions {
  * file.
  *
  * ```ts
- * const version = await fetchNodeReleaseVersion(relayUrl);
+ * const version = claimedRelease(attestationDoc, '2.3.109'); // the release the node names
  * const release = await fetchNodeRelease(cloudNodeReleaseUrl(DEFAULT_RELEASE_MIRROR, version));
  * const verifier = createQuoteVerifier({
  *   dcapVerify,
@@ -160,64 +154,15 @@ export interface SignedReleaseVerifierOptions extends Omit<TrustSignedReleaseOpt
  *
  * The node's choice of release is the one thing taken from it, and it is
  * bounded: only a genuinely signed release at or above `minReleaseVersion`
- * passes, and the quote must then be of exactly that release's image. Use it
- * as `connectCloud`'s `seal`, or with `createAttestedSealedFetch`;
- * {@link createSignedReleaseSealedFetch} does the latter for you.
+ * passes, and the quote must then be of exactly that release's image. Pass it
+ * as `CloudPolicy.verifyQuote` to choose where the release comes from yourself.
  */
 export declare function createSignedReleaseVerifier(options: SignedReleaseVerifierOptions): QuoteVerifier;
-export interface SignedReleaseSealedFetchOptions extends Omit<SignedReleaseVerifierOptions, 'release'> {
-    /** The TEE node's (the relay's) base URL. */
-    baseUrl: string;
-    /**
-     * Where to get the release the node says it runs, the version read from its
-     * `GET /admin-api/tee/info` each time it is attested. A string is the base
-     * URL of a mirror serving {@link cloudNodeReleaseUrl}'s path, defaulting to
-     * {@link DEFAULT_RELEASE_MIRROR}; a function gets the version and returns
-     * the release, e.g. from a file bundled with the app. Whichever it is, it is
-     * not trusted: the release is verified. `/tee/info` is read in the clear;
-     * for a node that refuses that, see `releaseVersion`.
-     */
-    releaseSource?: string | ((context: {
-        baseUrl: string;
-        version: string;
-        fetch: typeof fetch;
-    }) => Promise<SignedNodeRelease>);
-    /**
-     * The release to fetch when the node will not name one: a node that
-     * requires sealing (`[server.sealed] required`) and predates core#4196
-     * refuses `/tee/info` unsealed. Used only then; a node that answers is
-     * taken at its word. Either way untrusted: the quote must match the signed
-     * release, so a wrong version only fails the attestation.
-     */
-    releaseVersion?: string;
-    /** Also require the node to run this application with this bytecode hash. */
-    applicationId?: string;
-    applicationHash?: string;
-    /** Fetch for the release, the attestation and the envelopes. Defaults to global `fetch`. */
-    fetch?: typeof fetch;
-}
+/** `value` if it is a release version (`2.3.87`, `2.3.88-rc.1`); throws otherwise. */
+export declare function releaseVersion(value: unknown, what: string): string;
 /**
- * {@link createAttestedSealedFetch} for a TEE node known only by URL, trusting
- * whatever signed release at or above `minReleaseVersion` it runs: it reads
- * the release the node names from its `/tee/info` (or takes `releaseVersion`
- * when a node too old to serve that unsealed requires sealing), gets that release from
- * `releaseSource` (the public mirror unless you say otherwise), verifies its
- * signature, builds the quote verifier from its measurements, attests the node
- * and seals everything to it.
- *
- * ```ts
- * import { verify as dcapVerify } from '@phala/dcap-qvl';
- *
- * const relay = new RelayClient({
- *   relayUrl,
- *   fetch: createSignedReleaseSealedFetch({
- *     baseUrl: relayUrl,
- *     dcapVerify,
- *     profile: 'locked-read-only',
- *     minReleaseVersion: '2.3.87',
- *   }),
- *   ...
- * });
- * ```
+ * Order two release versions as semver does, and as core's
+ * `compare_release_versions`: numerically by `X.Y.Z`, a pre-release before its
+ * release, build metadata ignored.
  */
-export declare function createSignedReleaseSealedFetch(options: SignedReleaseSealedFetchOptions): typeof fetch;
+export declare function compareReleaseVersions(a: string, b: string): number;

package/dist/sealed/release.js

@@ -21,12 +21,11 @@
  * - the minimum release you pass, below which no release is accepted.
  *
  * What is not: the transport, the server that serves the release, and the
- * relay's choice of release. A relay can present any genuinely signed release
+ * node's choice of release. A node can present any genuinely signed release
  * at or above the minimum, and no other; its quote must then match that
  * release's measurements exactly, so it cannot claim one release and run
  * another.
  */
-import { createAttestedSealedFetch } from './sealed.js';
 import { verifyCosignBundle } from './sigstore.js';
 import { createQuoteVerifier, trustedMeasurementsFromReleases, } from './verify.js';
 /** The workflow that signs every mero-tee node release, and the issuer of its identity. */
@@ -111,63 +110,26 @@ export async function fetchNodeRelease(url, options = {}) {
     }
     return { version: release.version, publishedMrtds: release.publishedMrtds, bundle: release.bundle };
 }
+/** Where mero-tee publishes its releases' assets, as core's `calimero-tee-release` fetches them. */
+export const GITHUB_RELEASES = 'https://github.com/calimero-network/mero-tee/releases/download';
 /**
- * The release a mero-tee node image was built from, read from its name, e.g.
- * `merotee-ubuntu-questing-25-10-locked-read-only-2-3-87` is `2.3.87`. Throws
- * for any other name, including the suffixed images of unreleased builds.
+ * Node release `version` straight from its GitHub release (`mero-tee-v{version}`):
+ * `published-mrtds.json` and its cosign bundle, the files core's Rust client
+ * verifies. Only fetched: verify it with {@link trustSignedRelease}. GitHub's
+ * downloads send no CORS headers, so in a browser use a mirror
+ * ({@link cloudNodeReleaseUrl}) instead.
  */
-export function nodeReleaseVersionFromImage(osImage) {
-    const match = /^merotee-.+-(\d+)-(\d+)-(\d+)$/.exec(osImage);
-    if (!match)
-        throw new Error(`${JSON.stringify(osImage)} is not the image of a mero-tee node release`);
-    return `${Number(match[1])}.${Number(match[2])}.${Number(match[3])}`;
-}
-/**
- * The release the TEE node at `baseUrl` says it runs, from the image name its
- * `GET /admin-api/tee/info` reports. The node's own claim, and not trusted:
- * it only picks which signed release to fetch, and the quote must then match
- * that release's measurements.
- *
- * `/tee/info` is read in the clear, before any session exists. A node that
- * requires sealing serves it unsealed from core#4196 on; an older one refuses
- * it with `403 sealed_required`, and then this throws saying so.
- */
-export async function fetchNodeReleaseVersion(baseUrl, options = {}) {
-    const version = await readNodeReleaseVersion(baseUrl, options.fetch ?? fetch);
-    if (version === undefined) {
-        throw new Error(`${infoUrl(baseUrl)} was refused unsealed: the node requires sealing and is too old to name its ` +
-            "release before a session exists. Name the release it runs yourself (createSignedReleaseSealedFetch's " +
-            '`releaseVersion`), or upgrade the node');
-    }
-    return version;
-}
-function infoUrl(baseUrl) {
-    return `${baseUrl.replace(/\/+$/, '')}/admin-api/tee/info`;
-}
-/** As {@link fetchNodeReleaseVersion}, but `undefined` when the node refuses `/tee/info` as `sealed_required`. */
-async function readNodeReleaseVersion(baseUrl, givenFetch) {
-    const url = infoUrl(baseUrl);
-    const response = await givenFetch(url, { headers: { accept: 'application/json' } });
-    if (response.status === 403) {
-        const code = await response
-            .json()
-            .then((body) => body?.error?.code)
-            .catch(() => undefined);
-        if (code === 'sealed_required')
-            return undefined;
-    }
-    if (!response.ok)
-        throw new Error(`Fetching ${url} failed: HTTP ${response.status}`);
-    let osImage;
-    try {
-        osImage = (await response.json())?.data?.osImage;
-    }
-    catch {
-        throw new Error(`${url} did not answer with JSON`);
-    }
-    if (typeof osImage !== 'string')
-        throw new Error(`${url} did not name the node's image`);
-    return nodeReleaseVersionFromImage(osImage);
+export async function fetchGithubNodeRelease(version, options = {}) {
+    const tag = `mero-tee-v${releaseVersion(version, 'version')}`;
+    const base = `${(options.base ?? GITHUB_RELEASES).replace(/\/+$/, '')}/${tag}/published-mrtds.json`;
+    const get = async (url) => {
+        const response = await (options.fetch ?? fetch)(url);
+        if (!response.ok)
+            throw new Error(`Fetching ${url} failed: HTTP ${response.status}`);
+        return response.text();
+    };
+    const [publishedMrtds, bundle] = await Promise.all([get(base), get(`${base}.bundle.json`)]);
+    return { version, publishedMrtds, bundle };
 }
 /** Where the cloud at `cloudUrl` (e.g. `https://cloud.calimero.network`) mirrors node release `version`. */
 export function cloudNodeReleaseUrl(cloudUrl, version) {
@@ -181,7 +143,7 @@ export function cloudNodeReleaseUrl(cloudUrl, version) {
  * file.
  *
  * ```ts
- * const version = await fetchNodeReleaseVersion(relayUrl);
+ * const version = claimedRelease(attestationDoc, '2.3.109'); // the release the node names
  * const release = await fetchNodeRelease(cloudNodeReleaseUrl(DEFAULT_RELEASE_MIRROR, version));
  * const verifier = createQuoteVerifier({
  *   dcapVerify,
@@ -213,9 +175,8 @@ export async function trustSignedRelease(options) {
  *
  * The node's choice of release is the one thing taken from it, and it is
  * bounded: only a genuinely signed release at or above `minReleaseVersion`
- * passes, and the quote must then be of exactly that release's image. Use it
- * as `connectCloud`'s `seal`, or with `createAttestedSealedFetch`;
- * {@link createSignedReleaseSealedFetch} does the latter for you.
+ * passes, and the quote must then be of exactly that release's image. Pass it
+ * as `CloudPolicy.verifyQuote` to choose where the release comes from yourself.
  */
 export function createSignedReleaseVerifier(options) {
     releaseVersion(options.minReleaseVersion, 'minReleaseVersion');
@@ -237,54 +198,9 @@ export function createSignedReleaseVerifier(options) {
     };
     return Object.assign(verifier, { includeCollateral: true });
 }
-/**
- * {@link createAttestedSealedFetch} for a TEE node known only by URL, trusting
- * whatever signed release at or above `minReleaseVersion` it runs: it reads
- * the release the node names from its `/tee/info` (or takes `releaseVersion`
- * when a node too old to serve that unsealed requires sealing), gets that release from
- * `releaseSource` (the public mirror unless you say otherwise), verifies its
- * signature, builds the quote verifier from its measurements, attests the node
- * and seals everything to it.
- *
- * ```ts
- * import { verify as dcapVerify } from '@phala/dcap-qvl';
- *
- * const relay = new RelayClient({
- *   relayUrl,
- *   fetch: createSignedReleaseSealedFetch({
- *     baseUrl: relayUrl,
- *     dcapVerify,
- *     profile: 'locked-read-only',
- *     minReleaseVersion: '2.3.87',
- *   }),
- *   ...
- * });
- * ```
- */
-export function createSignedReleaseSealedFetch(options) {
-    const { baseUrl, releaseSource, releaseVersion: fallbackVersion, applicationId, applicationHash, fetch: givenFetch, ...verifierOptions } = options;
-    if (fallbackVersion !== undefined)
-        releaseVersion(fallbackVersion, 'releaseVersion');
-    const baseFetch = givenFetch ?? ((input, init) => fetch(input, init));
-    const release = async () => {
-        const version = fallbackVersion === undefined
-            ? await fetchNodeReleaseVersion(baseUrl, { fetch: baseFetch })
-            : ((await readNodeReleaseVersion(baseUrl, baseFetch)) ?? fallbackVersion);
-        return typeof releaseSource === 'function'
-            ? releaseSource({ baseUrl, version, fetch: baseFetch })
-            : fetchNodeRelease(cloudNodeReleaseUrl(releaseSource ?? DEFAULT_RELEASE_MIRROR, version), { fetch: baseFetch });
-    };
-    return createAttestedSealedFetch({
-        baseUrl,
-        verify: createSignedReleaseVerifier({ ...verifierOptions, release }),
-        applicationId,
-        applicationHash,
-        fetch: baseFetch,
-    });
-}
 const RELEASE_VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 /** `value` if it is a release version (`2.3.87`, `2.3.88-rc.1`); throws otherwise. */
-function releaseVersion(value, what) {
+export function releaseVersion(value, what) {
     const match = typeof value === 'string' ? RELEASE_VERSION.exec(value) : null;
     const pre = match?.[4];
     if (!match || (pre !== undefined && pre.split('.').some((id) => id === ''))) {
@@ -297,7 +213,7 @@ function releaseVersion(value, what) {
  * `compare_release_versions`: numerically by `X.Y.Z`, a pre-release before its
  * release, build metadata ignored.
  */
-function compareReleaseVersions(a, b) {
+export function compareReleaseVersions(a, b) {
     const [aCore, aPre] = splitVersion(a);
     const [bCore, bPre] = splitVersion(b);
     for (let i = 0; i < 3; i += 1) {

package/dist/sealed/sealed.d.ts

@@ -8,7 +8,7 @@
  * produce a response the client accepts.
  *
  * The client opens a session with a Noise NK handshake to the X25519 transport
- * key the node's quote commits to ({@link fetchAttestedTransportKey}). The
+ * key the node's quote commits to (`fetchAttestedKey`, `GET /attestation`). The
  * transport key only authenticates the node: the session keys come from both
  * sides' ephemeral keys, so once a session is gone (an hour at most) what was
  * sent in it cannot be opened, not even with the transport key. Each request
@@ -17,7 +17,7 @@
  * refuses one inside the envelope with a 501.
  *
  * The node's side, and the wire format this implements byte for byte, are in
- * core's `crates/server/src/sealed.rs`:
+ * core's `crates/sealed` (`calimero-sealed`):
  *
  * ```text
  * handshake   Noise_NK_25519_AESGCM_SHA256, prologue "calimero/sealed-http/v2"
@@ -33,9 +33,9 @@
  *   inner     u32 BE head length || head (JSON) || body
  * ```
  *
- * Use it by handing {@link createSealedFetch} to `MeroJsConfig.fetch`.
+ * `CalimeroClient` seals every request this way; {@link createSealedFetch} is
+ * the same channel as a plain `fetch`.
  */
-import type { TeeAttestRequest, TeeAttestResponseData } from '../admin-api/admin-types.js';
 import { initiate } from './noise.js';
 import type { DcapCollateral } from './verify.js';
 /** Where a session is opened, relative to the node's base URL. */
@@ -83,64 +83,17 @@ export interface VerifyTransportQuote {
         collateral?: DcapCollateral;
     }): Promise<boolean>;
     /**
-     * Ask the node for the collateral its quote verifies against, and pass it
-     * in as `collateral`. Off unless set, because a node that predates the field
-     * refuses the request.
+     * Set by the verifiers this package builds. A Calimero 1.0 node sends no
+     * collateral with its quote; the verifier fetches it itself.
      */
     readonly includeCollateral?: boolean;
 }
-/**
- * Ask a node for its transport key and accept it only if a quote you verified
- * commits to it.
- *
- * `applicationHash` (hex), when given, is the bytecode hash you expect the
- * attested application to have; the node is asked to bind that application,
- * and the quote only verifies if it runs that exact bytecode.
- */
-export declare function fetchAttestedTransportKey(admin: {
-    teeAttest(request: TeeAttestRequest): Promise<TeeAttestResponseData>;
-}, verify: VerifyTransportQuote, options?: {
-    applicationId?: string;
-    applicationHash?: string;
-}): Promise<Uint8Array>;
-export interface AttestedSealedFetchOptions {
-    /** The node's base URL. */
-    baseUrl: string;
-    /**
-     * Decides whether the node's quote is one you trust — typically
-     * {@link createQuoteVerifier}. Asked again whenever the node restarts.
-     */
-    verify: VerifyTransportQuote;
-    /** Also require the node to run this application with this bytecode hash. */
-    applicationId?: string;
-    applicationHash?: string;
-    /** Fetch that carries the attestation and the envelopes. Defaults to global `fetch`. */
-    fetch?: typeof fetch;
-}
-/**
- * {@link createSealedFetch} for a node you know only by URL: it attests the
- * node's transport key with `verify`, over `POST /admin-api/tee/attest` (the
- * one call that needs no credential and is never sealed), and seals everything
- * else to it. A restarted node is attested again, through the same verifier.
- *
- * This is what to hand a {@link RelayClient} for a TEE relay, so the warrant
- * and the method's arguments reach only the attested TD:
- *
- * ```ts
- * const relay = new RelayClient({
- *   relayUrl,
- *   fetch: createAttestedSealedFetch({ baseUrl: relayUrl, verify: createQuoteVerifier(...) }),
- *   ...
- * });
- * ```
- */
-export declare function createAttestedSealedFetch(options: AttestedSealedFetchOptions): typeof fetch;
 export interface SealedFetchOptions {
-    /** The node's base URL, as given to `MeroJsConfig.baseUrl`. */
+    /** The node's base URL. */
     baseUrl: string;
     /**
      * The node's attested transport key, or a function that attests and returns
-     * it — typically `() => fetchAttestedTransportKey(admin, verify)`. Given a
+     * it — typically `() => fetchAttestedKey(baseUrl, policy)`. Given a
      * function, a restarted node is handled: the key is attested again, through
      * your verifier, and the request retried once. Given bytes, a restart
      * surfaces as {@link StaleTransportKeyError}.
@@ -151,7 +104,6 @@ export interface SealedFetchOptions {
 }
 /**
  * A `fetch` that seals every request to the node's attested transport key.
- * Pass it as `MeroJsConfig.fetch`.
  *
  * A request for any URL outside `baseUrl` is refused rather than sent in the
  * clear: falling back to plaintext would silently undo the point of sealing.

package/dist/sealed/sealed.js

@@ -8,7 +8,7 @@
  * produce a response the client accepts.
  *
  * The client opens a session with a Noise NK handshake to the X25519 transport
- * key the node's quote commits to ({@link fetchAttestedTransportKey}). The
+ * key the node's quote commits to (`fetchAttestedKey`, `GET /attestation`). The
  * transport key only authenticates the node: the session keys come from both
  * sides' ephemeral keys, so once a session is gone (an hour at most) what was
  * sent in it cannot be opened, not even with the transport key. Each request
@@ -17,7 +17,7 @@
  * refuses one inside the envelope with a 501.
  *
  * The node's side, and the wire format this implements byte for byte, are in
- * core's `crates/server/src/sealed.rs`:
+ * core's `crates/sealed` (`calimero-sealed`):
  *
  * ```text
  * handshake   Noise_NK_25519_AESGCM_SHA256, prologue "calimero/sealed-http/v2"
@@ -33,9 +33,10 @@
  *   inner     u32 BE head length || head (JSON) || body
  * ```
  *
- * Use it by handing {@link createSealedFetch} to `MeroJsConfig.fetch`.
+ * `CalimeroClient` seals every request this way; {@link createSealedFetch} is
+ * the same channel as a plain `fetch`.
  */
-import { concat, fromHex, hex } from '../crypto/internal.js';
+import { concat } from '../crypto/internal.js';
 import { initiate } from './noise.js';
 /** Where a session is opened, relative to the node's base URL. */
 export const HANDSHAKE_PATH = '/sealed/v2/handshake';
@@ -92,92 +93,8 @@ export async function transportKeyBinding(inner, transportKey) {
     const digest = await crypto.subtle.digest('SHA-256', concat(utf8.encode(TRANSPORT_BINDING_DOMAIN), inner, transportKey));
     return new Uint8Array(digest);
 }
-/**
- * Ask a node for its transport key and accept it only if a quote you verified
- * commits to it.
- *
- * `applicationHash` (hex), when given, is the bytecode hash you expect the
- * attested application to have; the node is asked to bind that application,
- * and the quote only verifies if it runs that exact bytecode.
- */
-export async function fetchAttestedTransportKey(admin, verify, options = {}) {
-    if ((options.applicationId === undefined) !== (options.applicationHash === undefined)) {
-        throw new Error('applicationId and applicationHash are given together or not at all');
-    }
-    const nonce = hex(crypto.getRandomValues(new Uint8Array(32)));
-    const attested = await admin.teeAttest({
-        nonce,
-        applicationId: options.applicationId,
-        bindTransportKey: true,
-        ...(verify.includeCollateral ? { includeCollateral: true } : {}),
-    });
-    if (!attested.transportPublicKey) {
-        throw new Error('The node did not report a transport key; it predates sealed transport');
-    }
-    const transportKey = fromHex(attested.transportPublicKey, 'transportPublicKey', 32);
-    const inner = options.applicationHash
-        ? fromHex(options.applicationHash, 'applicationHash', 32)
-        : new Uint8Array(32);
-    const reportDataSuffix = hex(await transportKeyBinding(inner, transportKey));
-    const verified = await verify({
-        quoteB64: attested.quoteB64,
-        nonce,
-        reportDataSuffix,
-        collateral: attested.collateral,
-    });
-    if (!verified) {
-        throw new Error('The attestation did not verify, so its transport key is not trusted');
-    }
-    return transportKey;
-}
-/**
- * {@link createSealedFetch} for a node you know only by URL: it attests the
- * node's transport key with `verify`, over `POST /admin-api/tee/attest` (the
- * one call that needs no credential and is never sealed), and seals everything
- * else to it. A restarted node is attested again, through the same verifier.
- *
- * This is what to hand a {@link RelayClient} for a TEE relay, so the warrant
- * and the method's arguments reach only the attested TD:
- *
- * ```ts
- * const relay = new RelayClient({
- *   relayUrl,
- *   fetch: createAttestedSealedFetch({ baseUrl: relayUrl, verify: createQuoteVerifier(...) }),
- *   ...
- * });
- * ```
- */
-export function createAttestedSealedFetch(options) {
-    const baseFetch = options.fetch ?? ((input, init) => fetch(input, init));
-    const attestUrl = `${options.baseUrl.replace(/\/+$/, '')}/admin-api/tee/attest`;
-    const admin = {
-        async teeAttest(request) {
-            const response = await baseFetch(attestUrl, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify(request),
-            });
-            if (!response.ok) {
-                throw new Error(`The node refused to attest: HTTP ${response.status}`);
-            }
-            const body = (await response.json());
-            if (!body.data)
-                throw new Error('The attestation response is malformed');
-            return body.data;
-        },
-    };
-    return createSealedFetch({
-        baseUrl: options.baseUrl,
-        transportPublicKey: () => fetchAttestedTransportKey(admin, options.verify, {
-            applicationId: options.applicationId,
-            applicationHash: options.applicationHash,
-        }),
-        fetch: baseFetch,
-    });
-}
 /**
  * A `fetch` that seals every request to the node's attested transport key.
- * Pass it as `MeroJsConfig.fetch`.
  *
  * A request for any URL outside `baseUrl` is refused rather than sent in the
  * clear: falling back to plaintext would silently undo the point of sealing.
@@ -239,13 +156,18 @@ export function createSealedFetch(options) {
         request.headers.forEach((value, name) => headers.push([name, value]));
         const head = { method: request.method, path: url.pathname.slice(basePath.length) + url.search, headers };
         const body = new Uint8Array(await request.arrayBuffer());
+        // The caller's own signal, not `request.signal`: a Request's signal follows
+        // the one it was built from only through a weak reference (undici), so once
+        // the Request is garbage collected (it is, while a stream stays open) an
+        // abort no longer reaches the fetch, and an event stream never closes.
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
         const send = async (open) => {
             const { requestId, header, envelope } = await sealRequest(open, head, body);
             const response = await baseFetch(`${nodeUrl}${SEALED_PATH}`, {
                 method: 'POST',
                 headers: { 'content-type': SEALED_CONTENT_TYPE },
                 body: envelope,
-                signal: request.signal,
+                signal,
             });
             if (response.headers.get('content-type') !== SEALED_CONTENT_TYPE) {
                 throw await envelopeRefusal(response);

package/dist/sealed/verify.d.ts

@@ -5,9 +5,8 @@
  * signatures against Intel's root, the TCB status of the platform, the
  * measurements of the image, and that its report data is the nonce and the
  * binding this client asked for. {@link createQuoteVerifier} does all of that
- * here, with nothing but the node: the node hands over the Intel-signed
- * collateral with its quote (`includeCollateral`), and a node cannot forge
- * collateral, only choose which valid collateral to serve.
+ * here. A Calimero 1.0 node sends no collateral: the verifier fetches Intel's
+ * (`fetchCollateral`), which the node can neither forge nor choose.
  *
  * The DCAP verification itself — parsing the quote, checking its signature
  * chain and appraising its TCB level against the collateral — comes from a
@@ -20,8 +19,7 @@ import type { VerifyTransportQuote } from './sealed.js';
 /**
  * The collateral a quote is verified against — TCB info, QE identity, CRLs and
  * their chains — in dcap-qvl's form: byte fields are hex strings or byte
- * arrays. What `/admin-api/tee/attest` returns with `includeCollateral`, and
- * what `@phala/dcap-qvl`'s `getCollateral` fetches.
+ * arrays. What `@phala/dcap-qvl`'s `getCollateral` fetches.
  */
 export interface DcapCollateral {
     pck_crl_issuer_chain: string;
@@ -87,16 +85,15 @@ export interface QuoteVerifierOptions {
      */
     allowedTcbStatuses?: string[];
     /**
-     * Where to get collateral when the node sends none (it predates
-     * `includeCollateral`): for example
+     * Where to get collateral (a Calimero 1.0 node sends none): for example
      * `(quote) => getCollateral(PHALA_PCCS_URL, quote)` from `@phala/dcap-qvl`.
-     * Without it, such a node's quote is refused.
+     * Without it, a quote that came without collateral is refused.
      */
     fetchCollateral?: (quote: Uint8Array) => Promise<DcapCollateral>;
     /** The current time in milliseconds; defaults to `Date.now`. For tests. */
     now?: () => number;
 }
-/** A verifier for {@link fetchAttestedTransportKey}, which asks the node for collateral. */
+/** A quote verifier as this package builds one ({@link createQuoteVerifier}). */
 export type QuoteVerifier = VerifyTransportQuote & {
     readonly includeCollateral: true;
 };
@@ -122,10 +119,7 @@ export type QuoteVerifier = VerifyTransportQuote & {
  *   dcapVerify,
  *   ...trustedMeasurementsFromReleases([publishedMrtds], { profile: 'locked-read-only' }),
  * });
- * const fetch = createSealedFetch({
- *   baseUrl,
- *   transportPublicKey: () => fetchAttestedTransportKey(admin, verifier),
- * });
+ * const client = new CalimeroClient({ baseUrl, policy: { verifyQuote: verifier } });
  * ```
  */
 export declare function createQuoteVerifier(options: QuoteVerifierOptions): QuoteVerifier;