@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/relay-attestation/attest-node-key.js

@@ -1,110 +0,0 @@
-import { hex } from '../crypto/internal.js';
-/** Core's `ATTEST_KEY_BINDING_DOMAIN`. */
-const KEY_BINDING_DOMAIN = new TextEncoder().encode('calimero.tee-attest.key-binding.v1');
-/** Core's `MOCK_QUOTE_HEADER`: a mock quote is this, then the 64-byte report data. */
-const MOCK_QUOTE_HEADER = new TextEncoder().encode('MOCK_TDX_QUOTE_V1');
-/** A TDX v4 quote: 48-byte header, then the TD report body; report data at body offset 520. */
-const TDX_REPORT_DATA_OFFSET = 48 + 520;
-function concat(...parts) {
-    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-    let at = 0;
-    for (const p of parts) {
-        out.set(p, at);
-        at += p.length;
-    }
-    return out;
-}
-function equal(a, b) {
-    if (a.length !== b.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i += 1)
-        diff |= a[i] ^ b[i];
-    return diff === 0;
-}
-function fromBase64(b64) {
-    const bin = atob(b64);
-    const out = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; i += 1)
-        out[i] = bin.charCodeAt(i);
-    return out;
-}
-function fromHex32(value, label) {
-    if (typeof value !== 'string' || !/^[0-9a-fA-F]{64}$/.test(value)) {
-        throw new Error(`${label} must be 64 hex characters`);
-    }
-    const out = new Uint8Array(32);
-    for (let i = 0; i < 32; i += 1)
-        out[i] = Number.parseInt(value.slice(i * 2, i * 2 + 2), 16);
-    return out;
-}
-/** Core's `attest_key_binding(None, key)`. */
-export async function attestKeyBinding(nodeKey) {
-    const digest = await crypto.subtle.digest('SHA-256', concat(KEY_BINDING_DOMAIN, new Uint8Array(32), nodeKey));
-    return new Uint8Array(digest);
-}
-/** The 64 report-data bytes of a quote, read from the quote itself. */
-export function reportDataOf(quote) {
-    const mock = quote.length >= MOCK_QUOTE_HEADER.length &&
-        equal(quote.subarray(0, MOCK_QUOTE_HEADER.length), MOCK_QUOTE_HEADER);
-    const at = mock ? MOCK_QUOTE_HEADER.length : TDX_REPORT_DATA_OFFSET;
-    if (quote.length < at + 64) {
-        throw new Error(`the quote is too short to carry report data (${quote.length} bytes)`);
-    }
-    return { reportData: quote.slice(at, at + 64), mock };
-}
-/**
- * Ask a relay for a quote binding its node key to a fresh nonce, check the
- * binding, and return the key.
- */
-export async function attestRelayNodeKey(opts) {
-    const nonce = crypto.getRandomValues(new Uint8Array(32));
-    const url = `${opts.relayUrl.replace(/\/+$/, '')}/admin-api/tee/attest`;
-    const body = JSON.stringify({
-        nonce: hex(nonce),
-        bindNodeKey: true,
-        ...(opts.verify?.includeCollateral ? { includeCollateral: true } : {}),
-    });
-    const init = { method: 'POST', headers: { 'Content-Type': 'application/json' }, body };
-    const response = opts.fetch ? await opts.fetch(url, init) : await globalThis.fetch(url, init);
-    if (!response.ok) {
-        const text = await response.text().catch(() => '');
-        throw new Error(`the relay would not attest (HTTP ${response.status})${text ? `: ${text}` : ''}`);
-    }
-    const parsed = (await response.json());
-    const data = parsed.data ?? parsed;
-    if (typeof data.quoteB64 !== 'string')
-        throw new Error('the relay returned no quote');
-    const nodeKey = fromHex32(data.boundPublicKey, 'boundPublicKey');
-    const quote = fromBase64(data.quoteB64);
-    const { reportData, mock } = reportDataOf(quote);
-    if (mock) {
-        if (!opts.allowMock) {
-            throw new Error('the relay answered with a MOCK quote, which proves nothing about the hardware');
-        }
-    }
-    else if (opts.verify) {
-        const accepted = await opts.verify({
-            quoteB64: data.quoteB64,
-            nonce: hex(nonce),
-            reportDataSuffix: hex(await attestKeyBinding(nodeKey)),
-            ...(data.collateral ? { collateral: data.collateral } : {}),
-        });
-        if (!accepted) {
-            throw new Error("the relay's quote did not verify: not a trusted image, or not bound to this request");
-        }
-    }
-    else if (opts.verifyQuote) {
-        await opts.verifyQuote(quote);
-    }
-    else {
-        throw new Error('a real TDX quote needs a verify (or verifyQuote) to check its signature and measurements');
-    }
-    if (!equal(reportData.subarray(0, 32), nonce)) {
-        throw new Error('the quote does not carry our nonce: it was not made for this request');
-    }
-    if (!equal(reportData.subarray(32, 64), await attestKeyBinding(nodeKey))) {
-        throw new Error('the quote does not bind the key the relay named: refusing it');
-    }
-    return { nodeKey: hex(nodeKey), mock };
-}

package/dist/relay-attestation/index.d.ts

@@ -1 +0,0 @@
-export { attestRelayNodeKey, attestKeyBinding, reportDataOf, type AttestedNodeKey, type AttestRelayNodeKeyOptions, } from './attest-node-key.js';

package/dist/relay-attestation/index.js

@@ -1 +0,0 @@
-export { attestRelayNodeKey, attestKeyBinding, reportDataOf, } from './attest-node-key.js';

package/dist/request/caller-proof.d.ts

@@ -1,43 +0,0 @@
-/**
- * Assemble the credential a node reads from `X-Calimero-Proof`.
- *
- * A request-carried proof is three links, and the node needs all of them in one
- * header: the account root certified the device, the device (optionally)
- * certified a short-lived session key, and that key signed THIS request. Each
- * link is minted by its own function here — {@link signDeviceCert},
- * {@link signLoginStatement}, {@link signRequest} — and each already returns
- * the borsh encoding of the Rust type the node deserializes. Rust's
- * `CallerProof` is a plain struct of those three fields, and borsh writes a
- * struct as its fields back to back, so assembling the header is concatenation
- * rather than a fourth encoder.
- *
- * That is worth stating because it is load-bearing and it is not obvious: if it
- * were re-encoded here there would be a second spelling of a signed structure,
- * able to disagree with the one that was signed. `caller-proof.test.ts` pins the
- * concatenation against bytes produced by core itself.
- */
-/** The three links, each already hex-encoded by the function that signed it. */
-export interface CallerProofInput {
-    /**
-     * `signDeviceCert(...)` — the account root's certificate over the device key,
-     * with the genesis that names the account.
-     */
-    credential: string;
-    /**
-     * `signLoginStatement(...)`, when signing with a session key.
-     *
-     * Omit it on the two-link chain, where the device key signs the request
-     * itself. Omitting is not the same as passing an empty string: borsh writes
-     * `Option` as a tag byte, so the two produce different bytes and only one of
-     * them parses.
-     */
-    session?: string;
-    /** `signRequest(...)` — the signature over this exact method, path and body. */
-    request: string;
-}
-/**
- * Concatenate the three links into the header value.
- *
- * Returns hex, ready to present as `X-Calimero-Proof`.
- */
-export declare function callerProof(input: CallerProofInput): string;

package/dist/request/caller-proof.js

@@ -1,36 +0,0 @@
-/**
- * Assemble the credential a node reads from `X-Calimero-Proof`.
- *
- * A request-carried proof is three links, and the node needs all of them in one
- * header: the account root certified the device, the device (optionally)
- * certified a short-lived session key, and that key signed THIS request. Each
- * link is minted by its own function here — {@link signDeviceCert},
- * {@link signLoginStatement}, {@link signRequest} — and each already returns
- * the borsh encoding of the Rust type the node deserializes. Rust's
- * `CallerProof` is a plain struct of those three fields, and borsh writes a
- * struct as its fields back to back, so assembling the header is concatenation
- * rather than a fourth encoder.
- *
- * That is worth stating because it is load-bearing and it is not obvious: if it
- * were re-encoded here there would be a second spelling of a signed structure,
- * able to disagree with the one that was signed. `caller-proof.test.ts` pins the
- * concatenation against bytes produced by core itself.
- */
-import { fromHexUnsized, hex, concat } from "../crypto/internal.js";
-/**
- * Concatenate the three links into the header value.
- *
- * Returns hex, ready to present as `X-Calimero-Proof`.
- */
-export function callerProof(input) {
-    const credential = fromHexUnsized(input.credential, "credential");
-    const request = fromHexUnsized(input.request, "request signature");
-    // Borsh `Option<T>`: a single tag byte, then the value when present. A
-    // two-link chain is `None`, not an empty `Some` — the node reads the tag
-    // before anything else, so getting it backwards fails to parse rather than
-    // failing to verify, which at least is loud.
-    const session = input.session === undefined
-        ? new Uint8Array([0])
-        : concat(new Uint8Array([1]), fromHexUnsized(input.session, "session statement"));
-    return hex(concat(credential, session, request));
-}

package/dist/request/index.d.ts

@@ -1,3 +0,0 @@
-export { requestBodyHash, signRequest, type RequestSigInput, } from "./request-sig.js";
-export { callerProof, type CallerProofInput } from "./caller-proof.js";
-export { createProofSigner, type ProofRequest, type ProofSignerOptions, } from "./proof-signer.js";

package/dist/request/index.js

@@ -1,3 +0,0 @@
-export { requestBodyHash, signRequest, } from "./request-sig.js";
-export { callerProof } from "./caller-proof.js";
-export { createProofSigner, } from "./proof-signer.js";

package/dist/request/proof-signer.d.ts

@@ -1,49 +0,0 @@
-/**
- * Turn a device key into something the HTTP client can call per request.
- *
- * A session is a bearer token: mint once, present many times. A request-carried
- * proof is the opposite — it commits to one method, one path and one body, so
- * it has to be produced at the moment of the call, by something holding the
- * signing key. This is that something, shaped like `getAuthToken` so the key
- * stays with the caller and never reaches the transport.
- */
-/** What the transport knows about the call it is about to make. */
-export interface ProofRequest {
-    /** `GET`, `POST`, … exactly as it will be sent. */
-    method: string;
-    /** The path and query the node will see, as `signedPath` reads them. */
-    path: string;
-    /** The exact bytes that will be sent, if any. */
-    body?: unknown;
-}
-export interface ProofSignerOptions {
-    /** `signDeviceCert(...)`, hex. */
-    credential: string;
-    /**
-     * `signLoginStatement(...)`, hex — the three-link chain.
-     *
-     * Omit for the two-link chain, where `signerSecret` is the device key itself.
-     */
-    session?: string;
-    /**
-     * The ed25519 secret that signs each request, hex: the session key when
-     * `session` is set, otherwise the device key.
-     */
-    signerSecret: string;
-    /**
-     * How long each signature stays valid. Seconds, default 120.
-     *
-     * This is what bounds replay and nothing else does, so it is deliberately
-     * short and deliberately not configurable to "never". A clock skew allowance
-     * lives on the node; this only has to outlive the flight time.
-     */
-    ttlSeconds?: number;
-    /** Unix seconds. Injectable so a test does not depend on the wall clock. */
-    now?: () => number;
-}
-/**
- * Build the `X-Calimero-Proof` value for one request.
- *
- * Pass the result to the HTTP client's `getProof`.
- */
-export declare function createProofSigner(options: ProofSignerOptions): (request: ProofRequest) => Promise<string>;

package/dist/request/proof-signer.js

@@ -1,59 +0,0 @@
-/**
- * Turn a device key into something the HTTP client can call per request.
- *
- * A session is a bearer token: mint once, present many times. A request-carried
- * proof is the opposite — it commits to one method, one path and one body, so
- * it has to be produced at the moment of the call, by something holding the
- * signing key. This is that something, shaped like `getAuthToken` so the key
- * stays with the caller and never reaches the transport.
- */
-import { callerProof } from "./caller-proof.js";
-import { signRequest } from "./request-sig.js";
-/**
- * The bytes a body will actually be sent as.
- *
- * Refuses what it cannot hash without consuming or re-encoding. A stream can be
- * read once, and reading it here would send an empty body; `FormData` and
- * `URLSearchParams` are serialized by `fetch` in ways this cannot reproduce
- * byte for byte. Signing a guess would produce a signature over bytes that
- * never travelled, and the node would reject it with a signature error that
- * says nothing about the real cause — so this throws, naming the type.
- */
-function bodyBytes(body) {
-    if (body === undefined || body === null)
-        return new Uint8Array(0);
-    if (typeof body === "string")
-        return body;
-    if (body instanceof Uint8Array)
-        return body;
-    if (body instanceof ArrayBuffer)
-        return new Uint8Array(body);
-    if (ArrayBuffer.isView(body)) {
-        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
-    }
-    throw new Error(`a request-carried proof cannot commit to a ${body?.constructor?.name ?? typeof body} body: pass a string or bytes, or use a session for this call`);
-}
-/**
- * Build the `X-Calimero-Proof` value for one request.
- *
- * Pass the result to the HTTP client's `getProof`.
- */
-export function createProofSigner(options) {
-    const ttl = options.ttlSeconds ?? 120;
-    const clock = options.now ?? (() => Math.floor(Date.now() / 1000));
-    return async (request) => {
-        const issuedAt = clock();
-        return callerProof({
-            credential: options.credential,
-            session: options.session,
-            request: await signRequest({
-                method: request.method,
-                path: request.path,
-                body: bodyBytes(request.body),
-                issuedAt,
-                expiresAt: issuedAt + ttl,
-                signerSecret: options.signerSecret,
-            }),
-        });
-    };
-}

package/dist/request/request-sig.d.ts

@@ -1,99 +0,0 @@
-/**
- * Sign one HTTP request, so a caller's identity travels with it.
- *
- * This is the bottom link of the chain a delegated client presents. A session
- * has the node mint and remember something; this has the caller prove itself on
- * every call, so the node holds no session state and the same path works
- * whether or not the node runs a login provider at all.
- *
- * ```text
- * account root ──signs──▶ DeviceCert       cold, once, offline
- * device key   ──signs──▶ LoginStatement   once per session, hours
- * session key  ──signs──▶ RequestSig       per call   ◀── this module
- * ```
- *
- * **The middle link is optional.** A CLI or a server-side job signs with its
- * device key directly and presents two links; a browser keeping the device key
- * behind a hardware or extension boundary mints a session key and presents
- * three. The node's verifier handles both, so which you produce here is a
- * question about where your key lives, not about what the node accepts.
- *
- * **What it binds.** Method, path and query, and a hash of the body. A
- * signature for `GET /a?x=1` is not a signature for `POST /a?x=1`, for
- * `GET /a?x=2`, for `GET /b?x=1`, or for the same call with a different body.
- *
- * **The path includes the query string**, exactly as it goes on the request
- * line: no re-encoding, no reordering. A proxy between you and the node must
- * forward both unchanged, or the node refuses the proof.
- *
- * **The method is not normalized.** `HEAD` and `GET` are the same *permission*
- * and the node's permission layer folds them, but they are different requests.
- * Sign the method you are about to send.
- *
- * **Replay inside the window performs the identical request** and is bounded
- * rather than prevented — keep `expiresAt` short. A warrant, which authorizes a
- * change with lasting effect, carries a nonce ledger for this; a request
- * signature does not.
- *
- * **The byte contract is pinned in core**, at
- * `crates/account/src/tests/request_wire_fixture.rs`, for the same reason the
- * warrant and login ones are: the domains are `pub(crate)` there and the field
- * order is implicit in a `derive`, so nothing on that side forces anyone to
- * notice this file depends on both. This module's test asserts the same vectors.
- */
-import { fromHex } from "../crypto/internal.js";
-export declare const SIGN_DOMAIN: Uint8Array;
-/**
- * Commit to a request body.
- *
- * Always call it, including for a body-less request: an empty body hashes to a
- * value like any other, and there is no "absent body" encoding for a verifier
- * to disagree with you about.
- */
-export declare function requestBodyHash(body?: Uint8Array | string): Promise<Uint8Array>;
-/** What a caller is about to send. */
-export interface RequestSigInput {
-    /**
-     * The HTTP method, exactly as it will appear on the wire — `GET`, `POST`,
-     * `HEAD`. Not folded: see the module note.
-     */
-    method: string;
-    /**
-     * The path and query, exactly as on the request line:
-     * `/admin-api/blobs?context_id=…`. Use `signedPath` to take it from a URL.
-     */
-    path: string;
-    /**
-     * The request body, or nothing. Pass exactly the bytes you will send: the
-     * signature commits to their hash, so a body re-serialized between signing
-     * and sending is a signature for a different request.
-     */
-    body?: Uint8Array | string;
-    /** Unix seconds at signing. */
-    issuedAt: number | bigint;
-    /**
-     * Unix seconds after which the node must refuse it.
-     *
-     * Keep it short — minutes, not hours. It is what bounds replay, and nothing
-     * else does.
-     */
-    expiresAt: number | bigint;
-    /**
-     * The ed25519 signing secret, hex (32 bytes): the session key on the
-     * three-link chain, the device key on the two-link one.
-     *
-     * Never sent anywhere. It signs locally and only the signature travels.
-     */
-    signerSecret: string;
-}
-/**
- * Sign one request and return it hex-encoded, ready to present.
- *
- * Returns the encoding rather than an object for the reason `signWarrant` and
- * `signLoginStatement` do: the signature covers exactly these bytes, and a
- * caller that rebuilt the fields from JSON would have a second spelling able to
- * disagree with what was signed.
- */
-export declare function signRequest(input: RequestSigInput): Promise<string>;
-/** Re-exported so a caller can check a hex signer key before signing with it. */
-export { fromHex };

package/dist/request/request-sig.js

@@ -1,95 +0,0 @@
-/**
- * Sign one HTTP request, so a caller's identity travels with it.
- *
- * This is the bottom link of the chain a delegated client presents. A session
- * has the node mint and remember something; this has the caller prove itself on
- * every call, so the node holds no session state and the same path works
- * whether or not the node runs a login provider at all.
- *
- * ```text
- * account root ──signs──▶ DeviceCert       cold, once, offline
- * device key   ──signs──▶ LoginStatement   once per session, hours
- * session key  ──signs──▶ RequestSig       per call   ◀── this module
- * ```
- *
- * **The middle link is optional.** A CLI or a server-side job signs with its
- * device key directly and presents two links; a browser keeping the device key
- * behind a hardware or extension boundary mints a session key and presents
- * three. The node's verifier handles both, so which you produce here is a
- * question about where your key lives, not about what the node accepts.
- *
- * **What it binds.** Method, path and query, and a hash of the body. A
- * signature for `GET /a?x=1` is not a signature for `POST /a?x=1`, for
- * `GET /a?x=2`, for `GET /b?x=1`, or for the same call with a different body.
- *
- * **The path includes the query string**, exactly as it goes on the request
- * line: no re-encoding, no reordering. A proxy between you and the node must
- * forward both unchanged, or the node refuses the proof.
- *
- * **The method is not normalized.** `HEAD` and `GET` are the same *permission*
- * and the node's permission layer folds them, but they are different requests.
- * Sign the method you are about to send.
- *
- * **Replay inside the window performs the identical request** and is bounded
- * rather than prevented — keep `expiresAt` short. A warrant, which authorizes a
- * change with lasting effect, carries a nonce ledger for this; a request
- * signature does not.
- *
- * **The byte contract is pinned in core**, at
- * `crates/account/src/tests/request_wire_fixture.rs`, for the same reason the
- * warrant and login ones are: the domains are `pub(crate)` there and the field
- * order is implicit in a `derive`, so nothing on that side forces anyone to
- * notice this file depends on both. This module's test asserts the same vectors.
- */
-import { concat, domainHash, fromHex, hex, importSigningKey, u32le, u64le, } from "../crypto/internal.js";
-export const SIGN_DOMAIN = new TextEncoder().encode("calimero.auth.request.v2");
-/**
- * Its own domain, distinct from the signing one.
- *
- * The two are different jobs on the same bytes: this produces the commitment,
- * the other signs over it. Sharing a domain would make the commitment a
- * truncated disclosure of bytes something signs.
- */
-const BODY_DOMAIN = new TextEncoder().encode("calimero.auth.request.body.v1");
-/** A borsh `String`: its own `u32` little-endian length, then the UTF-8. */
-function borshString(value) {
-    const bytes = new TextEncoder().encode(value);
-    return concat(u32le(bytes.length), bytes);
-}
-/**
- * Commit to a request body.
- *
- * Always call it, including for a body-less request: an empty body hashes to a
- * value like any other, and there is no "absent body" encoding for a verifier
- * to disagree with you about.
- */
-export async function requestBodyHash(body = new Uint8Array(0)) {
-    const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
-    return domainHash(BODY_DOMAIN, [bytes]);
-}
-/**
- * Sign one request and return it hex-encoded, ready to present.
- *
- * Returns the encoding rather than an object for the reason `signWarrant` and
- * `signLoginStatement` do: the signature covers exactly these bytes, and a
- * caller that rebuilt the fields from JSON would have a second spelling able to
- * disagree with what was signed.
- */
-export async function signRequest(input) {
-    const key = await importSigningKey(input.signerSecret);
-    const bodyHash = await requestBodyHash(input.body);
-    const issuedAt = u64le(input.issuedAt);
-    const expiresAt = u64le(input.expiresAt);
-    const encoder = new TextEncoder();
-    const preimage = await domainHash(SIGN_DOMAIN, [
-        encoder.encode(input.method),
-        encoder.encode(input.path),
-        bodyHash,
-        issuedAt,
-        expiresAt,
-    ]);
-    const signature = new Uint8Array(await crypto.subtle.sign({ name: "Ed25519" }, key, preimage));
-    return hex(concat(borshString(input.method), borshString(input.path), bodyHash, issuedAt, expiresAt, signature));
-}
-/** Re-exported so a caller can check a hex signer key before signing with it. */
-export { fromHex };

package/dist/request-proof/authorizer.d.ts

@@ -1,41 +0,0 @@
-import type { Signer } from '../signer/index.js';
-/** What a keyholder holds: a certificate, and the key it certifies. */
-export interface ProofCredential {
-    /** The `AccountProof<DeviceCert>` from `signDeviceCert`, hex. */
-    credential: string;
-    /** The certified device's ed25519 secret, hex. Or pass `signer`. */
-    deviceSecret?: string;
-    /** A signer, for a key that cannot be exported to hex. */
-    signer?: Signer;
-    /** Seconds each signature stays valid. Defaults to `signRequestProof`'s. */
-    validForSeconds?: number;
-}
-/** One request, as the proof has to see it. */
-export interface RequestToAuthorize {
-    method: string;
-    /** Path and query, as `signedPath` reads them from the URL being fetched. */
-    path: string;
-    /** The body exactly as it will be sent, if there is one. */
-    body?: string | Uint8Array;
-}
-/**
- * A per-request authorizer. Returns the headers to merge into the request.
- *
- * Returning headers rather than setting them keeps the caller in charge of the
- * request: a transport that already has an `Authorization` header can decide
- * which wins, and core decides the same way — a request carrying a token is
- * answered by that token, and the proof is only consulted when there is none.
- */
-export type RequestAuthorizer = (request: RequestToAuthorize) => Promise<Record<string, string>>;
-/**
- * Turn a device cert into a {@link RequestAuthorizer}.
- *
- * The credential is validated once, here, rather than on the first request:
- * a malformed one otherwise surfaces as a 401 from whichever read happened to
- * run first, which reads as "the node refused me" and sends the caller looking
- * in the wrong place.
- */
-export declare function createProofAuthorizer(credential: ProofCredential): RequestAuthorizer;
-/** The path and query a proof signs, read from the parsed URL: the serialization
- * `fetch` puts on the request line, base-URL prefix and escapes included. */
-export declare function signedPath(url: string): string;

package/dist/request-proof/authorizer.js

@@ -1,60 +0,0 @@
-/**
- * A device cert, as something every transport can authenticate a request with.
- *
- * {@link signRequestProof} signs one request. This wraps it in the shape the
- * rest of the SDK can consume without knowing what a proof is: a function from
- * `(method, path, body)` to the headers that request should carry. The HTTP
- * client, the SSE client and the admin client each take that function, so a
- * keyholder is authenticated the same way on all three and none of them holds a
- * second copy of the encoding.
- *
- * ## Why the authorizer, and not a token
- *
- * A bearer token is one value reused across requests, so `getAuthToken` can be
- * called once and its result cached. A proof commits to the method, the path and
- * the body, so it cannot be: every request needs its own, and the signature has
- * to be taken where those three are known. That is the whole reason this is a
- * per-request callback rather than another token provider.
- *
- * Measured against a node built from core `aecba573b`: reads answer `200` to a
- * proof with no session, `/sse` answers `200` and `/ws` upgrades `101`, and the
- * listings are caller-scoped — an account in one of the node's two namespaces is
- * shown one, and a WS subscribe naming a context it is not a member of is
- * refused while the one it is a member of is granted.
- */
-import { REQUEST_PROOF_HEADER, signRequestProof } from './request-proof.js';
-/**
- * Turn a device cert into a {@link RequestAuthorizer}.
- *
- * The credential is validated once, here, rather than on the first request:
- * a malformed one otherwise surfaces as a 401 from whichever read happened to
- * run first, which reads as "the node refused me" and sends the caller looking
- * in the wrong place.
- */
-export function createProofAuthorizer(credential) {
-    if (!credential.credential) {
-        throw new Error('a proof authorizer needs the `credential` from signDeviceCert');
-    }
-    if (!credential.deviceSecret && !credential.signer) {
-        throw new Error('a proof authorizer needs either `deviceSecret` or `signer`');
-    }
-    return async ({ method, path, body }) => {
-        const proof = await signRequestProof({
-            method,
-            path,
-            body,
-            credential: credential.credential,
-            deviceSecret: credential.deviceSecret,
-            signer: credential.signer,
-            validForSeconds: credential.validForSeconds,
-        });
-        return { [REQUEST_PROOF_HEADER]: proof };
-    };
-}
-/** The path and query a proof signs, read from the parsed URL: the serialization
- * `fetch` puts on the request line, base-URL prefix and escapes included. */
-export function signedPath(url) {
-    // A relative URL resolves as `fetch` resolves it: against the page, if any.
-    const parsed = new URL(url, globalThis.location?.href ?? 'http://localhost');
-    return parsed.pathname + parsed.search;
-}

package/dist/request-proof/index.d.ts

@@ -1,4 +0,0 @@
-export { signRequestProof, REQUEST_PROOF_HEADER } from './request-proof.js';
-export type { RequestProofInput } from './request-proof.js';
-export { createProofAuthorizer, signedPath } from './authorizer.js';
-export type { ProofCredential, RequestAuthorizer, RequestToAuthorize } from './authorizer.js';

package/dist/request-proof/index.js

@@ -1,2 +0,0 @@
-export { signRequestProof, REQUEST_PROOF_HEADER } from './request-proof.js';
-export { createProofAuthorizer, signedPath } from './authorizer.js';