@calimero-network/mero-js 26.11.0 → 27.0.1

package/dist/relay/relay-client.js

@@ -1,518 +0,0 @@
-/**
- * Write to a context through a relay, holding nothing but a signing key.
- *
- * # What this replaces
- *
- * `sdk.rpc.execute` asks a node to run a method *as itself*: it needs a node,
- * that node needs to be a member, and the caller needs a credential on it. For
- * a browser tab, a phone, or an agent, none of those three is available — the
- * runtime cannot compile WASM against materialized state, never received the
- * scope key that seals the deltas, and has no account on anybody's node.
- *
- * This client is the other path. The caller signs a warrant locally, the relay
- * runs the method as the *author's* principal, and the resulting delta is
- * attributed to the author's account and device — their replica slot, their
- * membership, their name in the app. The relay's key signs the envelope and
- * nothing else.
- *
- * # The three preconditions, and why they are checked in this order
- *
- * `describe()` answers the first two in one call, before anything is signed:
- * the relay's executor account and signing key and the release the context's
- * group names (which the warrant must name), and whether it holds
- * `CAN_AUTHOR_ON_BEHALF` on the owning group. The third,
- * that the author's account is a member, only the group knows, and it surfaces
- * as a refusal.
- *
- * Checking before signing is not politeness. A warrant consumes a nonce from a
- * monotonic per-device sequence, and one minted against the wrong executor is
- * unspendable: the number is gone and the write never happened.
- */
-import { releaseVersionBytes, signWarrant } from '../warrant/warrant.js';
-import { resolveSigner } from '../signer/signer.js';
-import { signCreationWarrant } from '../warrant/creation-warrant.js';
-import { signGovernanceWarrant } from '../warrant/governance-warrant.js';
-import { defaultCapabilitiesSetOp, targetApplicationSetOp, foundedNamespaceId, namespaceCreatedOp, } from '../warrant/governance-op.js';
-import { HTTPError } from '../http-client/web-client.js';
-import { pathSegment } from '../http-client/path-segment.js';
-import { fromHex, hex } from '../crypto/internal.js';
-/** How long a freshly minted warrant stays presentable, in seconds. */
-const DEFAULT_TTL_SECONDS = 300;
-/**
- * Thrown when a relay refuses an intent, carrying which precondition failed.
- *
- * The distinction is the whole reason this type exists. A `403` from this
- * endpoint means one of several unrelated things — no grant on the relay, the
- * relay is a TEE replica (`ReadOnlyTee`) or a `ReadOnly` member (neither ever
- * relays), the author is
- * not a member or is read-only in the context, or the nonce was already spent
- * — and they send a caller somewhere completely different: ask an admin, pick
- * a relay the namespace admits in `relay` mode, ask for an invitation, or just
- * retry. Collapsing them into "forbidden" makes a retryable replay look
- * like a permissions bug.
- */
-export class IntentRefusedError extends Error {
-    constructor(
-    /** The relay's own explanation, verbatim. */
-    reason, 
-    /** `true` when re-presenting the same intent under a *fresh* warrant may work. */
-    retryable, status) {
-        super(`relay refused the intent (HTTP ${status}): ${reason}`);
-        this.reason = reason;
-        this.retryable = retryable;
-        this.status = status;
-        this.name = 'IntentRefusedError';
-    }
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/**
- * `Retry-After`, as milliseconds — seconds or an HTTP date, per RFC 9110.
- *
- * Returns `null` when the header is absent or unusable, so the caller falls back
- * to its own backoff rather than treating a malformed header as "retry now".
- */
-function retryAfterMs(headers) {
-    const raw = headers?.get?.('Retry-After');
-    if (!raw)
-        return null;
-    const seconds = Number.parseInt(raw, 10);
-    if (Number.isFinite(seconds) && seconds >= 0)
-        return seconds * 1000;
-    const at = Date.parse(raw);
-    if (Number.isFinite(at))
-        return Math.max(0, at - Date.now());
-    return null;
-}
-export class RelayClient {
-    constructor(config) {
-        this.config = config;
-        this.baseUrl = config.relayUrl.replace(/\/+$/, '');
-        const injected = config.fetch;
-        this.fetchImpl = injected
-            ? (input, init) => injected(input, init)
-            : (input, init) => globalThis.fetch(input, init);
-        this.timeoutMs = config.timeoutMs ?? 10000;
-        this.rateLimitRetries = config.rateLimitRetries ?? 3;
-    }
-    /**
-     * The relay's origin, trailing slash stripped.
-     *
-     * Exposed because a relay **is a node**: the same origin that answers the
-     * intents routes also answers `/auth/challenge`, `/auth/token`, `/sse` and
-     * `/ws`. Anything building an observing session over this relay needs the
-     * URL, and asking the caller to pass it a second time is how the two drift.
-     */
-    get relayUrl() {
-        return this.baseUrl;
-    }
-    /** The author's account, hex — whose consent every warrant here carries. */
-    get authorAccount() {
-        return this.config.authorAccount;
-    }
-    /**
-     * The author's `AccountProof<DeviceCert>`, hex.
-     *
-     * The same credential `login()` wants, which is why it is readable: a caller
-     * that already handed it to this client should not have to hand an identical
-     * copy to the login as well, where the two could disagree.
-     */
-    get authorProof() {
-        return this.config.authorProof;
-    }
-    /**
-     * The author device's signer.
-     *
-     * A {@link Signer} and never the secret: this returns something that can
-     * *sign*, so no caller of a `RelayClient` gains the ability to read a key
-     * that was passed in as `deviceSecret`. That asymmetry is the point — the
-     * login needs a signature, not key material.
-     */
-    async authorSigner() {
-        return resolveSigner(this.config.deviceSecret, this.config.signer, 'deviceSecret');
-    }
-    /**
-     * Ask the relay what it can do in `contextId`.
-     *
-     * Cheap and unauthenticated on a relay that serves delegated execution
-     * publicly, which is what makes it usable as a precondition check rather than
-     * as diagnostics after a failure.
-     */
-    async describe(contextId) {
-        const body = await this.json('GET', `/admin-api/contexts/${pathSegment(contextId)}/intents`);
-        return body.data;
-    }
-    /**
-     * Mint a warrant for `method(args)` and present it to the relay.
-     *
-     * One intent, once: the warrant authorizes exactly this method and these
-     * arguments in exactly this context, and its nonce is spent by the network on
-     * apply. Nothing accumulates and nothing is reusable.
-     */
-    async execute(contextId, method, argsJson = {}) {
-        // Asked on every write: the release moves with each upgrade of the group, and a
-        // warrant pinning the one before is refused. All of it is checked before the nonce.
-        const described = await this.describe(contextId);
-        const executor = this.checkedExecutor(described);
-        const releaseBytecodeId = hex(fromHex(described.releaseBytecodeId ?? '', "the relay's releaseBytecodeId", 32));
-        const releaseVersion = described.releaseVersion ?? '';
-        releaseVersionBytes(releaseVersion);
-        // Resolved before the nonce, so a misconfigured key burns none.
-        const signer = await this.authorSigner();
-        const nonce = await this.config.nonces.next();
-        const ttl = this.config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
-        const warrant = await signWarrant({
-            context: contextId,
-            authorAccount: this.config.authorAccount,
-            executor: executor.executorAccount,
-            executorKey: executor.executorKey,
-            releaseBytecodeId,
-            releaseVersion,
-            method,
-            argsJson,
-            nonce,
-            notAfter: BigInt(Math.floor(Date.now() / 1000)) + BigInt(ttl),
-            signer,
-        });
-        const body = await this.json('POST', `/admin-api/contexts/${pathSegment(contextId)}/intents`, { method, argsJson, warrant, authorProof: this.config.authorProof });
-        return { rootHash: body.data.rootHash, returns: body.data.returns ?? null };
-    }
-    /**
-     * Publish one presence statement through the relay (`presence-intents`).
-     *
-     * Not retried on 429: presence resends every 2.5 s anyway, and a retry would
-     * only queue behind the next resend. A refusal throws with its `status`.
-     */
-    async presenceIntent(contextId, body) {
-        await this.jsonOnce('POST', `/admin-api/contexts/${pathSegment(contextId)}/presence-intents`, body);
-    }
-    /**
-     * Ask the relay what it can do about creating contexts in `groupId`.
-     *
-     * Pass `author` (an account, hex) to also learn whether that account may
-     * create here — `authorMayCreate` is present only then.
-     */
-    async describeCreation(groupId, opts = {}) {
-        const query = opts.author ? `?author=${encodeURIComponent(opts.author)}` : '';
-        const body = await this.json('GET', `/admin-api/groups/${pathSegment(groupId)}/context-intents${query}`);
-        return body.data;
-    }
-    /**
-     * Create a context in a group through the relay, as the author.
-     *
-     * Always asks {@link describeCreation} first — with the author, so both
-     * standing checks happen before anything is signed. A relay without standing
-     * in the group, or an author without `CAN_CREATE_CONTEXT`, is refused here as
-     * an {@link IntentRefusedError} *before* a nonce is taken: the nonce source
-     * is monotonic, and a warrant nobody will spend burns one for nothing.
-     *
-     * The creation warrant's nonce is spent in the new context's per-device
-     * ledger — the same one later `execute` calls in that context draw from — so
-     * it comes from the configured {@link NonceSource} like any other warrant.
-     *
-     * Sealing: nothing here is plaintext-specific. The request goes through the
-     * injected `fetch`, so a `createAttestedSealedFetch` seals it exactly as it
-     * seals `execute`. Whether the relay *accepts* it sealed is the node's call:
-     * a proxy-auth relay only admits sealed requests for routes `merod` serves
-     * without a credential, so `/admin-api/groups/:id/context-intents` must be on
-     * that list on the core side or the request comes back
-     * `403 sealed_route_unguarded`.
-     */
-    async createContext(input) {
-        const described = await this.describeCreation(input.groupId, {
-            author: this.config.authorAccount,
-        });
-        if (!described.canCreateOnBehalf) {
-            throw new IntentRefusedError(`the relay (${described.executorAccount}) has no standing to act for members of group ` +
-                `${described.groupId}; an admin must admit it as a relay or grant it CAN_AUTHOR_ON_BEHALF ` +
-                '(checked before signing — no nonce was spent)', false, 403);
-        }
-        if (described.authorMayCreate === false) {
-            throw new IntentRefusedError(`the author (${this.config.authorAccount}) may not create contexts in group ` +
-                `${described.groupId}; it needs CAN_CREATE_CONTEXT or admin ` +
-                '(checked before signing — no nonce was spent)', false, 403);
-        }
-        const executor = this.checkedExecutor(described);
-        const initArgs = input.initArgs ?? {};
-        // Resolved before the nonce, so a misconfigured key burns none.
-        const signer = await this.authorSigner();
-        const nonce = await this.config.nonces.next();
-        const ttl = this.config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
-        const { warrant } = await signCreationWarrant({
-            group: input.groupId,
-            seed: input.seed,
-            authorAccount: this.config.authorAccount,
-            executor: executor.executorAccount,
-            executorKey: executor.executorKey,
-            applicationId: input.applicationId,
-            serviceName: input.serviceName,
-            name: input.name,
-            initArgs,
-            nonce,
-            notAfter: BigInt(Math.floor(Date.now() / 1000)) + BigInt(ttl),
-            signer,
-        });
-        const body = await this.json('POST', `/admin-api/groups/${pathSegment(input.groupId)}/context-intents`, { warrant, authorProof: this.config.authorProof, initArgs });
-        return {
-            contextId: body.data.contextId,
-            groupId: body.data.groupId,
-            memberPublicKey: body.data.memberPublicKey,
-        };
-    }
-    /**
-     * Ask the relay whether it may publish governance ops for members of
-     * `groupId`, and which account and key a warrant must name.
-     */
-    async describeGovernance(groupId) {
-        const body = await this.json('GET', `/admin-api/groups/${pathSegment(groupId)}/governance-intents`);
-        return body.data;
-    }
-    /**
-     * Publish one governance op through the relay, as the author.
-     *
-     * The warrant commits to the op's exact bytes and is scoped to `groupId`, so
-     * the relay can neither change what the op does nor spend it elsewhere. Every
-     * peer applies the op as the author, so the author's own rights decide
-     * (`MANAGE_MEMBERS` to add a member, `CAN_CREATE_SUBGROUP` to create a
-     * subgroup, and so on); a lack of them comes back as an
-     * {@link IntentRefusedError} from the relay.
-     *
-     * Always asks {@link describeGovernance} first and refuses *before* taking a
-     * nonce when the relay has no standing, for the reason `createContext` does.
-     * The nonce comes from the configured {@link NonceSource}; it is spent in a
-     * per-group ledger, and a monotonic source is correct for it as for every
-     * other warrant.
-     */
-    async govern(input) {
-        const described = await this.describeGovernance(input.groupId);
-        if (!described.canActOnBehalf) {
-            throw new IntentRefusedError(`the relay (${described.executorAccount}) has no standing to act for members of group ` +
-                `${described.groupId}; an admin must admit it as a relay or grant it CAN_AUTHOR_ON_BEHALF ` +
-                '(checked before signing, no nonce was spent)', false, 403);
-        }
-        const executor = this.checkedExecutor(described);
-        // Resolved before the nonce, so a misconfigured key burns none.
-        const signer = await this.authorSigner();
-        const nonce = await this.config.nonces.next();
-        const ttl = this.config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
-        const warrant = await signGovernanceWarrant({
-            scope: input.groupId,
-            op: input.op,
-            authorAccount: this.config.authorAccount,
-            executor: executor.executorAccount,
-            executorKey: executor.executorKey,
-            nonce,
-            notAfter: BigInt(Math.floor(Date.now() / 1000)) + BigInt(ttl),
-            signer,
-        });
-        const data = await this.postGovernance(input.groupId, input.op, warrant);
-        return { groupId: data.groupId };
-    }
-    /**
-     * Found a namespace through the relay, with the author as its founder, owner
-     * and admin. For an account with no node, this is how it gets a namespace at
-     * all.
-     *
-     * The author signs the exact genesis (`NamespaceCreatedV2`, carrying the
-     * author's own credential and the salt) under a root-plane governance
-     * warrant scoped to the new namespace's id, which is derived from the
-     * author's account and the salt, so the relay can neither choose another id
-     * nor found it for anyone else. The relay takes an identity in the new
-     * namespace, mints its key, publishes the genesis, and is seated as the
-     * founding relay (a `Member` holding `CAN_AUTHOR_ON_BEHALF`), so later
-     * `govern`, `createContext` and `execute` calls in the namespace work
-     * through it straight away. A TEE relay then admits itself as the
-     * namespace's first TEE; `teeEnabled` reports whether it did.
-     *
-     * The executor cannot be learned from the relay first: the namespace does not
-     * exist, so `describeGovernance` has nothing to answer about. It comes from
-     * `input.executor` only, and without it this throws before taking a nonce.
-     * The nonce is spent in the new namespace's ledger.
-     *
-     * With `defaultCapabilities`, the founder then sets the namespace's default
-     * capability mask through the same relay (a second warrant, a second nonce)
-     * and `defaultCapabilitiesSet` reports whether it landed. A failure there
-     * does not throw, since the namespace is already founded.
-     *
-     * Refusals (`400`/`403`) come back as {@link IntentRefusedError}; a salt
-     * that names an existing namespace is a `409`, an `HTTPError`.
-     */
-    async foundNamespace(input) {
-        if (!input?.executor) {
-            throw new Error("foundNamespace needs the relay's account and signing key: pass executor " +
-                '(checked before signing, no nonce was spent)');
-        }
-        const executor = this.checkedExecutor(input.executor);
-        const salt = input.salt
-            ? hex(fromHex(input.salt, 'salt', 32))
-            : hex(crypto.getRandomValues(new Uint8Array(32)));
-        const namespaceId = await foundedNamespaceId(this.config.authorAccount, salt);
-        const op = namespaceCreatedOp({
-            founder: this.config.authorAccount,
-            credential: this.config.authorProof,
-            salt,
-        });
-        // Encoded (and so validated) before anything is signed: a mask the relay
-        // would refuse must not cost the founding a nonce.
-        const capabilitiesOp = input.defaultCapabilities === undefined
-            ? undefined
-            : defaultCapabilitiesSetOp(input.defaultCapabilities);
-        const applicationOp = input.application ? targetApplicationSetOp(input.application) : undefined;
-        // Resolved before the nonce, so a misconfigured key burns none.
-        const signer = await this.authorSigner();
-        const nonce = await this.config.nonces.next();
-        const ttl = this.config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
-        const warrant = await signGovernanceWarrant({
-            scope: namespaceId,
-            op,
-            authorAccount: this.config.authorAccount,
-            executor: executor.executorAccount,
-            executorKey: executor.executorKey,
-            nonce,
-            notAfter: BigInt(Math.floor(Date.now() / 1000)) + BigInt(ttl),
-            signer,
-        });
-        const data = await this.postGovernance(namespaceId, op, warrant);
-        const founded = {
-            namespaceId: data.groupId,
-            salt,
-            teeEnabled: data.teeEnabled ?? false,
-            ...(data.teeError ? { teeError: data.teeError } : {}),
-        };
-        // Follow-up ops, each under its own warrant, on the namespace root: the
-        // founder is its admin and the relay was seated to act for members, so they
-        // go through the ordinary `govern` path. The namespace exists whatever
-        // happens here, so a failure is reported rather than thrown. The
-        // application first: without it the namespace can hold no context at all.
-        let result = founded;
-        const message = (err) => (err instanceof Error ? err.message : String(err));
-        if (applicationOp) {
-            try {
-                await this.govern({ groupId: founded.namespaceId, op: applicationOp });
-                result = { ...result, applicationSet: true };
-            }
-            catch (err) {
-                result = { ...result, applicationSet: false, applicationError: message(err) };
-            }
-        }
-        if (capabilitiesOp) {
-            try {
-                await this.govern({ groupId: founded.namespaceId, op: capabilitiesOp });
-                result = { ...result, defaultCapabilitiesSet: true };
-            }
-            catch (err) {
-                result = { ...result, defaultCapabilitiesSet: false, defaultCapabilitiesError: message(err) };
-            }
-        }
-        return result;
-    }
-    async postGovernance(groupId, op, warrant) {
-        const body = await this.json('POST', `/admin-api/groups/${pathSegment(groupId)}/governance-intents`, {
-            warrant,
-            authorProof: this.config.authorProof,
-            op: hex(op.bytes),
-        });
-        return body.data;
-    }
-    /**
-     * The relay's answer, checked against a configured account.
-     * Decoded here so a relay naming no key is refused before a nonce is taken.
-     */
-    checkedExecutor(answered) {
-        const executor = {
-            executorAccount: hex(fromHex(answered.executorAccount ?? '', "the relay's executorAccount", 32)),
-            executorKey: hex(fromHex(answered.executorKey ?? '', "the relay's executorKey", 32)),
-        };
-        const configured = this.config.executorAccount;
-        if (configured && configured.toLowerCase() !== executor.executorAccount) {
-            throw new Error(`configured executorAccount ${configured} is not the relay's account ` +
-                `${executor.executorAccount}; a warrant naming it would be unspendable`);
-        }
-        return executor;
-    }
-    /**
-     * One request, waiting out a rate limit rather than failing the caller.
-     *
-     * The relay's ingress limits the delegated-execution routes to 20 requests a
-     * second per source IP, burst 40 — tighter than everything else it serves,
-     * because those two routes are the ones it answers to anonymous callers.
-     *
-     * Retrying a 429 is safe here in a way retrying most refusals is not: the
-     * limiter sits *first* in the middleware chain, so a throttled request never
-     * reached the node and its warrant nonce was never spent. The same bytes can
-     * go again. Contrast the spent-nonce 403 below, which needs a fresh warrant.
-     *
-     * `Retry-After` is honoured when the ingress sends one; otherwise the wait
-     * doubles from a little over the limiter's own window, which is the shortest
-     * delay that can actually clear.
-     */
-    async json(method, path, body) {
-        let wait = 250;
-        for (let attempt = 0;; attempt += 1) {
-            try {
-                return await this.jsonOnce(method, path, body);
-            }
-            catch (err) {
-                const limited = err instanceof HTTPError && err.status === 429;
-                if (!limited || attempt >= this.rateLimitRetries)
-                    throw err;
-                const after = retryAfterMs(err.headers);
-                await sleep(after ?? wait);
-                wait *= 2;
-            }
-        }
-    }
-    async jsonOnce(method, path, body) {
-        const headers = { Accept: 'application/json' };
-        if (body !== undefined)
-            headers['Content-Type'] = 'application/json';
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-        let response;
-        try {
-            response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-                method,
-                headers,
-                body: body === undefined ? undefined : JSON.stringify(body),
-                signal: controller.signal,
-            });
-        }
-        catch (err) {
-            throw new HTTPError(0, err instanceof Error ? err.name : 'NetworkError', `${this.baseUrl}${path}`, new Headers(), err instanceof Error ? err.message : String(err));
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            // 400 and 403 are both caller preconditions and core separates them
-            // deliberately: 400 means re-sending the same bytes cannot help, 403
-            // means the bytes are genuine but authority is missing. Only the spent
-            // nonce is worth retrying, and only under a fresh warrant.
-            if (response.status === 400 || response.status === 403) {
-                const reason = extractReason(text);
-                throw new IntentRefusedError(reason, /nonce/i.test(reason), response.status);
-            }
-            throw new HTTPError(response.status, response.statusText, `${this.baseUrl}${path}`, response.headers, text);
-        }
-        // `presence-intents` answers an accepted update with no body.
-        if (response.status === 204)
-            return undefined;
-        return (await response.json());
-    }
-}
-/** Pull the relay's explanation out of its error body, or fall back to the raw text. */
-function extractReason(bodyText) {
-    if (!bodyText)
-        return 'no reason given';
-    try {
-        const parsed = JSON.parse(bodyText);
-        for (const candidate of [parsed.error, parsed.message]) {
-            if (typeof candidate === 'string' && candidate)
-                return candidate;
-        }
-    }
-    catch {
-        // Not JSON — the text itself is the best available explanation.
-    }
-    return bodyText;
-}

package/dist/relay-attestation/attest-node-key.d.ts

@@ -1,66 +0,0 @@
-/**
- * Learn a relay's node signing key from its TEE attestation.
- *
- * `login()` binds a session to the node key the client names, and that key must
- * never be taken from the node being logged in to on its word — the answering
- * party would choose what the device signs about. A TEE quote is different: the
- * node cannot put a key into it that the TEE did not bind. With `bindNodeKey`,
- * core commits the node's signing key into the quote's report data:
- *
- *   report_data = nonce (32)  ‖  SHA-256("calimero.tee-attest.key-binding.v1" ‖ 0^32 ‖ key)
- *
- * (the 32 zero bytes stand for "no application", core's `attest_key_binding`).
- * So the client sends a fresh nonce, reads the report data out of the RAW quote
- * bytes — never the server's parsed rendering of them — and accepts the returned
- * key only if both halves match.
- *
- * That proves the key came from whatever produced the quote. Whether that is a
- * genuine TDX guest running a trusted image is the quote's signature and
- * measurements, which this module does not judge: a real quote needs a
- * `verifyQuote` supplied by the caller, and a mock quote (a dev-only format with
- * no signature at all) is refused unless `allowMock` is set.
- */
-import type { VerifyTransportQuote } from '../sealed/sealed.js';
-export interface AttestedNodeKey {
-    /** The relay's node signing key, hex (32 bytes), as the quote binds it. */
-    readonly nodeKey: string;
-    /** True when the quote was a mock — no TEE vouched for anything. */
-    readonly mock: boolean;
-}
-export interface AttestRelayNodeKeyOptions {
-    readonly relayUrl: string;
-    /**
-     * Accept a mock quote. DEV/TEST ONLY: a mock quote carries no signature, so it
-     * proves nothing about the hardware — only that the node bound this key into
-     * something it produced for our nonce.
-     */
-    readonly allowMock?: boolean;
-    /**
-     * Verify a real quote's signature chain and measurements; throw to refuse.
-     * Required for a non-mock quote: without it the binding would be checked
-     * against bytes nothing has authenticated.
-     */
-    readonly verifyQuote?: (quote: Uint8Array) => Promise<void>;
-    /**
-     * Verify a real quote the way a sealed transport does: a
-     * {@link VerifyTransportQuote}, such as `createSignedReleaseVerifier` (the
-     * relay's signed mero-tee release, Intel's chain, every register of its
-     * image). Called with our nonce and the node-key binding as the expected
-     * report data, and with the relay's collateral when it asks for it. Takes
-     * precedence over `verifyQuote`.
-     */
-    readonly verify?: VerifyTransportQuote;
-    readonly fetch?: typeof fetch;
-}
-/** Core's `attest_key_binding(None, key)`. */
-export declare function attestKeyBinding(nodeKey: Uint8Array): Promise<Uint8Array>;
-/** The 64 report-data bytes of a quote, read from the quote itself. */
-export declare function reportDataOf(quote: Uint8Array): {
-    reportData: Uint8Array;
-    mock: boolean;
-};
-/**
- * Ask a relay for a quote binding its node key to a fresh nonce, check the
- * binding, and return the key.
- */
-export declare function attestRelayNodeKey(opts: AttestRelayNodeKeyOptions): Promise<AttestedNodeKey>;