@shuttle.technology/authorization 0.0.0-stage → 0.1.0

package/dist/requestGrant.js

@@ -0,0 +1,243 @@
+// Mode C request-signing key and request grant (source §1.4, §2.2, §2.5).
+//
+// The private key is a non-extractable P-256 WebCrypto key held only in this
+// package's memory; only its public kty/crv/x/y JWK is ever enrolled. The
+// protected grant result is retained beside the exact key that produced it: a
+// result paired with another key, an altered thumbprint or a lost key all
+// refuse proof generation locally and require explicit re-enrollment with
+// fresh passkey UV. Nothing here reads or writes browser storage, and nothing
+// here re-enrolls on refresh, reload or login.
+import { ClientFlowError, base64url, canonicalDecimal, integer, opaqueId, record } from "./auth.js";
+import { canonicalJSONBytes } from "./canonicalize.js";
+/** MaxRequestGrantRecipients is the source §2.8 allowlist bound. */
+export const MaxRequestGrantRecipients = 10;
+/** MaxRequestGrantLifetimeSeconds is the source §2.5 ceiling of fifteen minutes. */
+export const MaxRequestGrantLifetimeSeconds = 15 * 60;
+const maxUint256 = (1n << 256n) - 1n;
+const coordinate = /^[A-Za-z0-9_-]{43}$/;
+const grantToken = /^[A-Za-z0-9_-]{43}$/;
+const grantNetwork = /^[A-Za-z0-9_.-]{1,64}$/;
+const grantRecipient = /^[\x21-\x7e]{1,256}$/;
+/**
+ * generateRequestSigningKey creates the non-extractable P-256 key of source
+ * §2.5. It refuses a runtime that returns an extractable private key or a
+ * public JWK carrying any private member, so a weakened WebCrypto cannot
+ * silently become custody of a user key.
+ */
+export async function generateRequestSigningKey(crypto) {
+    if (!crypto?.subtle || typeof crypto.subtle.generateKey !== "function" || typeof crypto.getRandomValues !== "function") {
+        throw new ClientFlowError("runtime_capability_unavailable");
+    }
+    const algorithm = { name: "ECDSA", namedCurve: "P-256" };
+    const pair = (await crypto.subtle.generateKey(algorithm, false, ["sign", "verify"]));
+    if (!pair?.privateKey || !pair.publicKey || pair.privateKey.extractable !== false)
+        throw new ClientFlowError("request_key_extractable");
+    const exported = await crypto.subtle.exportKey("jwk", pair.publicKey);
+    const publicJwk = exactPublicJwk(exported);
+    return {
+        handle: base64url(crypto.getRandomValues(new Uint8Array(16))),
+        publicJwk,
+        thumbprint: await jwkThumbprint(crypto, publicJwk),
+        privateKey: pair.privateKey,
+    };
+}
+/**
+ * jwkThumbprint is the RFC 7638 SHA-256 thumbprint in unpadded base64url over
+ * exactly the required EC members. The canonicalizer already orders them
+ * lexicographically, which is the order RFC 7638 prescribes.
+ */
+export async function jwkThumbprint(crypto, key) {
+    if (!crypto?.subtle || typeof crypto.subtle.digest !== "function")
+        throw new ClientFlowError("runtime_capability_unavailable");
+    const canonical = canonicalJSONBytes({ crv: key.crv, kty: key.kty, x: key.x, y: key.y });
+    return base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", canonical)));
+}
+/**
+ * buildRequestGrantEnrollment returns the closed `session.authorize_requests`
+ * OperationCreate. Every bound is validated locally first, so an empty or
+ * over-length allowlist, a duplicate or wildcard recipient and a noncanonical
+ * or out-of-range ceiling never leave the client.
+ */
+export function buildRequestGrantEnrollment(key, enrollment) {
+    const declared = record(enrollment, ["ownerId", "servicePrincipalId", "walletId", "network", "recipientAllowlist", "maxAmountRaw", "maxFeeRaw"]);
+    if (!opaqueId(declared.ownerId) || !opaqueId(declared.servicePrincipalId) || !opaqueId(declared.walletId) ||
+        typeof declared.network !== "string" || !grantNetwork.test(declared.network) ||
+        !rawQuantity(declared.maxAmountRaw, true) || !rawQuantity(declared.maxFeeRaw, false)) {
+        throw new ClientFlowError("invalid_request_grant_enrollment");
+    }
+    const allowlist = exactAllowlist(declared.recipientAllowlist, "invalid_request_grant_enrollment");
+    return {
+        kind: "session.authorize_requests",
+        owner_type: "account",
+        owner_id: declared.ownerId,
+        payload: {
+            public_jwk: { kty: key.publicJwk.kty, crv: key.publicJwk.crv, x: key.publicJwk.x, y: key.publicJwk.y },
+            service_principal_id: declared.servicePrincipalId,
+            wallet_id: declared.walletId,
+            network: declared.network,
+            recipient_allowlist: allowlist,
+            max_amount_raw: declared.maxAmountRaw,
+            max_fee_raw: declared.maxFeeRaw,
+        },
+    };
+}
+/**
+ * enrollRequestGrant performs one explicit enrollment: it never runs from a
+ * refresh, reload or login callback, and it returns the protected grant result
+ * paired with the key that will sign under it. The caller must have obtained
+ * the hosted passkey confirmation through `confirm`; no proof is generated here
+ * and no mediated request is sent.
+ */
+export async function enrollRequestGrant(host, key, enrollment, keys) {
+    if (!opaqueId(keys?.create) || !opaqueId(keys?.execute))
+        throw new ClientFlowError("invalid_idempotency_key");
+    const create = buildRequestGrantEnrollment(key, enrollment);
+    const admitted = await host.create(create, keys.create);
+    if (!opaqueId(admitted?.operationId))
+        throw new ClientFlowError("invalid_server_response");
+    const confirmed = await host.confirm(admitted.operationId);
+    if (confirmed?.operationId !== admitted.operationId || !canonicalDecimal(confirmed.version))
+        throw new ClientFlowError("invalid_server_response");
+    await host.execute(admitted.operationId, confirmed.version, keys.execute);
+    return parseRequestGrantResultEnvelope(await host.result(admitted.operationId), key, enrollment).result;
+}
+/**
+ * parseRequestGrantResultEnvelope accepts the `{request_id,result}` protected
+ * result envelope and requires the grant to belong to this key and to the
+ * enrollment that was submitted.
+ */
+export function parseRequestGrantResultEnvelope(payload, key, enrollment) {
+    const root = record(payload, ["request_id", "result"]);
+    if (!opaqueId(root.request_id))
+        throw new ClientFlowError("invalid_server_response");
+    const result = parseRequestGrantResult(root.result);
+    assertGrantMatches(result, key, enrollment);
+    return { requestId: root.request_id, result };
+}
+/** parseRequestGrantResult accepts exactly the closed grant result of source §2.2. */
+export function parseRequestGrantResult(payload) {
+    const root = record(payload, ["request_grant_id", "public_key_thumbprint", "server_time", "expires_at", "binding", "bounds"]);
+    if (typeof root.request_grant_id !== "string" || !grantToken.test(root.request_grant_id) ||
+        typeof root.public_key_thumbprint !== "string" || !grantToken.test(root.public_key_thumbprint) ||
+        !integer(root.server_time) || !integer(root.expires_at) || root.expires_at <= root.server_time ||
+        root.expires_at - root.server_time > MaxRequestGrantLifetimeSeconds) {
+        throw new ClientFlowError("invalid_request_grant_result");
+    }
+    const raw = record(root.binding, ["tenant_id", "application_id", "environment_id", "client_id", "account_id", "session_id", "service_principal_id", "wallet_id", "wallet_generation", "mapping_version"]);
+    const binding = {
+        tenantId: boundIdentifier(raw.tenant_id), applicationId: boundIdentifier(raw.application_id), environmentId: boundIdentifier(raw.environment_id),
+        clientId: boundIdentifier(raw.client_id), accountId: boundIdentifier(raw.account_id), sessionId: boundIdentifier(raw.session_id),
+        servicePrincipalId: boundIdentifier(raw.service_principal_id), walletId: boundIdentifier(raw.wallet_id),
+        walletGeneration: boundVersion(raw.wallet_generation), mappingVersion: boundVersion(raw.mapping_version),
+    };
+    const bounds = record(root.bounds, ["network", "recipient_allowlist", "max_amount_raw", "max_fee_raw"]);
+    if (typeof bounds.network !== "string" || !grantNetwork.test(bounds.network) ||
+        !rawQuantity(bounds.max_amount_raw, true) || !rawQuantity(bounds.max_fee_raw, false)) {
+        throw new ClientFlowError("invalid_request_grant_result");
+    }
+    return {
+        requestGrantId: root.request_grant_id,
+        publicKeyThumbprint: root.public_key_thumbprint,
+        serverTime: root.server_time,
+        expiresAt: root.expires_at,
+        binding,
+        bounds: {
+            network: bounds.network, recipientAllowlist: exactAllowlist(bounds.recipient_allowlist, "invalid_request_grant_result"),
+            maxAmountRaw: bounds.max_amount_raw, maxFeeRaw: bounds.max_fee_raw,
+        },
+    };
+}
+/**
+ * RequestGrantStore keeps one grant result beside the exact key that owns it,
+ * in memory only. It never touches browser storage, never renews a grant and
+ * never re-enrolls: a released, absent or expired pairing reports
+ * `request_grant_reenrollment_required` so the caller performs an explicit
+ * fresh-UV enrollment instead.
+ */
+export class RequestGrantStore {
+    #paired;
+    /** pair refuses any grant result that is not this key's own enrolled grant. */
+    pair(key, grant, enrollment) {
+        assertGrantMatches(grant, key, enrollment);
+        const paired = Object.freeze({ grant, key });
+        this.#paired = paired;
+        return paired;
+    }
+    /**
+     * current returns the live pairing. An absent pairing is a lost key, and an
+     * expired grant is over: neither is repaired locally.
+     */
+    current(serverNowSeconds) {
+        const paired = this.#paired;
+        if (!paired)
+            throw new ClientFlowError("request_grant_reenrollment_required");
+        if (!integer(serverNowSeconds) || serverNowSeconds >= paired.grant.expiresAt)
+            throw new ClientFlowError("request_grant_reenrollment_required");
+        return paired;
+    }
+    /** release forgets the pairing, as logout or a lost key requires. */
+    release() {
+        this.#paired = undefined;
+    }
+}
+/**
+ * assertGrantMatches is the local pairing check of source §1.4: the result must
+ * carry this key's RFC 7638 thumbprint and the exact bounds and owner the
+ * client enrolled. A mismatch is a refusal, never a renegotiated grant.
+ */
+export function assertGrantMatches(grant, key, enrollment) {
+    if (grant.publicKeyThumbprint !== key.thumbprint)
+        throw new ClientFlowError("request_grant_mismatch");
+    if (grant.binding.accountId !== enrollment.ownerId || grant.binding.servicePrincipalId !== enrollment.servicePrincipalId ||
+        grant.binding.walletId !== enrollment.walletId || grant.bounds.network !== enrollment.network ||
+        grant.bounds.maxAmountRaw !== enrollment.maxAmountRaw || grant.bounds.maxFeeRaw !== enrollment.maxFeeRaw) {
+        throw new ClientFlowError("request_grant_mismatch");
+    }
+    if (grant.bounds.recipientAllowlist.length !== enrollment.recipientAllowlist.length ||
+        grant.bounds.recipientAllowlist.some((recipient, index) => recipient !== enrollment.recipientAllowlist[index])) {
+        throw new ClientFlowError("request_grant_mismatch");
+    }
+}
+function exactPublicJwk(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new ClientFlowError("invalid_request_key");
+    const jwk = value;
+    // A WebCrypto export carries advertised usage metadata; every other member,
+    // and any private member, refuses the key outright.
+    const allowed = new Set(["kty", "crv", "x", "y", "ext", "key_ops"]);
+    if (Object.keys(jwk).some((member) => !allowed.has(member)))
+        throw new ClientFlowError("invalid_request_key");
+    if (jwk.kty !== "EC" || jwk.crv !== "P-256" || typeof jwk.x !== "string" || typeof jwk.y !== "string" ||
+        !coordinate.test(jwk.x) || !coordinate.test(jwk.y)) {
+        throw new ClientFlowError("invalid_request_key");
+    }
+    return Object.freeze({ kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y });
+}
+function exactAllowlist(value, code) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > MaxRequestGrantRecipients)
+        throw new ClientFlowError(code);
+    const allowlist = [];
+    for (const recipient of value) {
+        if (typeof recipient !== "string" || !grantRecipient.test(recipient) || allowlist.includes(recipient))
+            throw new ClientFlowError(code);
+        allowlist.push(recipient);
+    }
+    return Object.freeze(allowlist);
+}
+function rawQuantity(value, positive) {
+    if (!canonicalDecimal(value))
+        return false;
+    const quantity = BigInt(value);
+    return quantity <= maxUint256 && (!positive || quantity > 0n);
+}
+function boundIdentifier(value) {
+    if (!opaqueId(value))
+        throw new ClientFlowError("invalid_request_grant_result");
+    return value;
+}
+/** boundVersion accepts the canonical decimal versions of source §2.2; zero is never a live version. */
+function boundVersion(value) {
+    if (!canonicalDecimal(value) || value === "0")
+        throw new ClientFlowError("invalid_request_grant_result");
+    return value;
+}

package/dist/sends.d.ts

@@ -0,0 +1,89 @@
+import { type PageOptions } from './pages.ts';
+import { type ReplaceAction, type UserWalletEffectState, type UserWalletState } from './walletOperations.ts';
+import type { WalletEvent } from './walletEvents.ts';
+/** The recorded final fate of a send's transfer. It never changes. */
+export interface TransferOutcome {
+    readonly state: 'confirmed' | 'failed' | 'expired';
+    /** When the provider recorded the own-wallet system's report. */
+    readonly observedAt: string;
+    readonly transactionHash?: string;
+    readonly failureReason?: string;
+    /** The account's own send whose transaction the network included in this transfer's place; only with failureReason nonce_used. */
+    readonly replacedByOperationId?: string;
+}
+/**
+ * One send of the history. network, asset, recipient and amountRaw are absent
+ * once the operation's material retention expired (materialPurged): the send
+ * stays listed with its state and its transfer, and without details.
+ */
+export interface ListedSend {
+    readonly operationId: string;
+    readonly state: UserWalletState;
+    readonly effectState: UserWalletEffectState;
+    /**
+     * session_authorized: the account's session authorized a send from a linked
+     * wallet (no passkey, since 14 October 2026); user_confirmed: the passkey
+     * confirmed it; user_request_signed: a service sent it on the user's signed
+     * request; "" while it waits for a passkey.
+     */
+    readonly authorizationBasis: '' | 'user_confirmed' | 'session_authorized' | 'user_request_signed';
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly materialPurged: boolean;
+    /** Present for a send from a linked wallet. */
+    readonly linkedWalletId?: string;
+    /** Present for a send from a wallet bound in the provider. */
+    readonly walletId?: string;
+    readonly network?: string;
+    readonly asset?: string;
+    readonly recipient?: string;
+    readonly amountRaw?: string;
+    /** The sending address, once the own-wallet system prepared the transfer of a linked wallet. */
+    readonly address?: string;
+    /**
+     * Present for a send that replaces an earlier one the network had not
+     * included: that send's operation, and "speed_up" or "cancel". network,
+     * asset, recipient and amountRaw are then what the replacing transaction
+     * itself moves, for a cancel nothing ("0") to the wallet's own address.
+     */
+    readonly replacesOperationId?: string;
+    readonly replaceAction?: ReplaceAction;
+    /** The text the transfer carries to its recipient, on TON. */
+    readonly comment?: string;
+    /** The network's hash of a send from a linked wallet the own-wallet system accepted. */
+    readonly transactionHash?: string;
+    /** The final fate of that send's transfer; absent until transferStatus() read a final state. */
+    readonly transfer?: TransferOutcome;
+}
+export interface SendPage {
+    readonly requestId: string;
+    readonly items: readonly ListedSend[];
+    readonly hasMore: boolean;
+    readonly nextCursor?: string;
+}
+/** The path of one page of the send history. */
+export declare function sendsPath(options?: PageOptions): {
+    path: string;
+    signal?: AbortSignal;
+};
+/** Parses one closed page of the send history. */
+export declare function parseSendPage(payload: unknown): SendPage;
+/**
+ * Says whether a wallet event is the network's record of the transaction with
+ * this hash on this network: true or false where an event's sourceReference
+ * is the transaction hash, and undefined on every other network, where
+ * nothing ties an event to a hash yet. On the EVM networks and TRON the two
+ * are one hexadecimal hash and differ at most in a 0x prefix and letter case.
+ * On Solana both are the transaction's signature in base58, where case is
+ * part of the value. On TON the event names the transaction the network made
+ * and the own-wallet system names the message it sent; the two hashes differ.
+ */
+export declare function eventOfTransaction(event: WalletEvent, networkId: string, transactionHash: string): boolean | undefined;
+/**
+ * The wallet events that record one listed send on its network: the
+ * withdrawal from the sending wallet and any activity of the same
+ * transaction. It returns undefined where events cannot be tied to the send
+ * (no hash yet, details purged, or a network without that tie), and an empty
+ * list where they can and none of the given events is of this send.
+ */
+export declare function sendEvents(send: ListedSend, events: readonly WalletEvent[]): readonly WalletEvent[] | undefined;

package/dist/sends.js

@@ -0,0 +1,127 @@
+// The account's history of sends: GET /v1/operations narrowed to wallet.send,
+// newest first. Every row is one send with what a history shows of it: where,
+// what, how much, to whom, its state, its transaction hash and, once the
+// own-wallet system reported it, the final fate of its transfer.
+import { ClientFlowError, opaqueId, record, rfc3339UTC } from './auth.js';
+import { pageEnvelope, pageRequest } from './pages.js';
+import { parseUserWalletOperation, walletMaterialPurged } from './walletOperations.js';
+const hashPattern = /^[A-Za-z0-9_.:-]{1,128}$/;
+/** The path of one page of the send history. */
+export function sendsPath(options) {
+    const { path, signal } = pageRequest('/v1/operations', options);
+    return { path: `${path}${path.includes('?') ? '&' : '?'}kind=wallet.send`, signal };
+}
+/** Parses one closed page of the send history. */
+export function parseSendPage(payload) {
+    const page = pageEnvelope(payload);
+    const items = page.items.map(parseListedSend);
+    // Newest first: a page out of order is not this list.
+    if (items.some((item, index) => index > 0 && Date.parse(items[index - 1].createdAt) < Date.parse(item.createdAt)))
+        fault();
+    const out = { requestId: page.request_id, items: Object.freeze(items), hasMore: page.has_more };
+    return Object.freeze(page.has_more ? { ...out, nextCursor: page.next_cursor } : out);
+}
+function parseListedSend(payload) {
+    const item = record(payload, ['operation'], ['transaction_hash', 'transfer']);
+    const raw = item.operation;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw) || raw.kind !== 'wallet.send')
+        fault();
+    const send = listedSend(item.operation);
+    if (item.transaction_hash !== undefined) {
+        if (typeof item.transaction_hash !== 'string' || !hashPattern.test(item.transaction_hash) || send.linkedWalletId === undefined)
+            fault();
+        send.transactionHash = item.transaction_hash;
+    }
+    if (item.transfer !== undefined) {
+        if (send.linkedWalletId === undefined)
+            fault();
+        send.transfer = parseTransferOutcome(item.transfer);
+        if (send.transfer.replacedByOperationId === send.operationId)
+            fault();
+    }
+    return Object.freeze(send);
+}
+/**
+ * One send of the account: from a linked wallet authorized by its session,
+ * confirmed with its passkey, or forwarded by a service on the person's signed
+ * request (Mode C, from a bound or a linked wallet), each read with the parser
+ * of the projection the provider serves for it.
+ */
+function listedSend(payload) {
+    const operation = parseUserWalletOperation(payload);
+    const send = {
+        operationId: operation.id, state: operation.state, effectState: operation.effectState, authorizationBasis: operation.authorizationBasis,
+        createdAt: operation.createdAt, expiresAt: operation.expiresAt, materialPurged: walletMaterialPurged(operation.display),
+    };
+    if (operation.linkedWallet)
+        send.linkedWalletId = operation.linkedWallet.linkedWalletId;
+    if (operation.walletId !== undefined)
+        send.walletId = operation.walletId;
+    const display = operation.display;
+    if (!walletMaterialPurged(display) && display.kind === 'wallet.send') {
+        send.network = display.network;
+        send.asset = display.asset;
+        send.recipient = display.recipient;
+        send.amountRaw = display.amountRaw;
+        if ('address' in display && display.address !== undefined)
+            send.address = display.address;
+        if ('comment' in display && display.comment !== undefined)
+            send.comment = display.comment;
+        if ('replacesOperationId' in display && display.replacesOperationId !== undefined) {
+            send.replacesOperationId = display.replacesOperationId;
+            send.replaceAction = display.replaceAction;
+        }
+    }
+    return send;
+}
+function parseTransferOutcome(payload) {
+    const t = record(payload, ['observed_at', 'state'], ['transaction_hash', 'failure_reason', 'replaced_by_operation_id']);
+    const hash = t.transaction_hash, reason = t.failure_reason, replacedBy = t.replaced_by_operation_id;
+    if (!['confirmed', 'failed', 'expired'].includes(t.state) || !rfc3339UTC(t.observed_at) ||
+        (hash !== undefined && (typeof hash !== 'string' || !hashPattern.test(hash))) || (t.state === 'confirmed' && hash === undefined) ||
+        (reason !== undefined && (t.state !== 'failed' || typeof reason !== 'string' || reason.length === 0 || new TextEncoder().encode(reason).length > 1024 || /[\x00-\x1f\x7f-\x9f]/.test(reason))) ||
+        (replacedBy !== undefined && (reason !== 'nonce_used' || !opaqueId(replacedBy))))
+        fault();
+    const out = { state: t.state, observedAt: t.observed_at };
+    if (hash !== undefined)
+        out.transactionHash = hash;
+    if (replacedBy !== undefined)
+        out.replacedByOperationId = replacedBy;
+    if (reason !== undefined)
+        out.failureReason = reason;
+    return Object.freeze(out);
+}
+/**
+ * Says whether a wallet event is the network's record of the transaction with
+ * this hash on this network: true or false where an event's sourceReference
+ * is the transaction hash, and undefined on every other network, where
+ * nothing ties an event to a hash yet. On the EVM networks and TRON the two
+ * are one hexadecimal hash and differ at most in a 0x prefix and letter case.
+ * On Solana both are the transaction's signature in base58, where case is
+ * part of the value. On TON the event names the transaction the network made
+ * and the own-wallet system names the message it sent; the two hashes differ.
+ */
+export function eventOfTransaction(event, networkId, transactionHash) {
+    const family = networkId.split(':', 1)[0];
+    if (family === 'solana')
+        return event.networkId === networkId && /^[1-9A-HJ-NP-Za-km-z]{64,88}$/.test(transactionHash) && event.sourceReference === transactionHash;
+    if (family !== 'eip155' && family !== 'tron')
+        return undefined;
+    const bare = (value) => value.toLowerCase().replace(/^0x/, '');
+    return event.networkId === networkId && /^(0x)?[0-9a-fA-F]{64}$/.test(transactionHash) && bare(event.sourceReference) === bare(transactionHash);
+}
+/**
+ * The wallet events that record one listed send on its network: the
+ * withdrawal from the sending wallet and any activity of the same
+ * transaction. It returns undefined where events cannot be tied to the send
+ * (no hash yet, details purged, or a network without that tie), and an empty
+ * list where they can and none of the given events is of this send.
+ */
+export function sendEvents(send, events) {
+    if (send.network === undefined || send.transactionHash === undefined)
+        return undefined;
+    if (eventOfTransaction({ networkId: send.network, sourceReference: '' }, send.network, send.transactionHash) === undefined)
+        return undefined;
+    return events.filter((event) => eventOfTransaction(event, send.network, send.transactionHash) === true);
+}
+function fault() { throw new ClientFlowError('invalid_server_response'); }

package/dist/slice4.d.ts

@@ -0,0 +1,173 @@
+import { type IdentityMethod, type NextAction } from "./auth.ts";
+import { type WalletLimitsDisplay } from "./walletLimits.ts";
+import { type LinkedEnrollmentDisplay, type LinkedRequestGrantEnrollmentCreate, type LinkedRequestGrantResult } from "./modeCLinked.ts";
+export interface HostedIdentityFlow {
+    requestId: string;
+    flowId: string;
+    launchUrl: string;
+    expiresAt: number;
+}
+export interface PasskeyBootstrapResult {
+    requestId: string;
+    credentialId: string;
+    version: string;
+    state: "active";
+}
+export interface VerifiedIdentityResult {
+    requestId: string;
+    verifiedIdentityHandle: string;
+    expiresAt: number;
+}
+export type IdentityVerificationMethod = IdentityMethod;
+/**
+ * AccountIdentity is one active sign-in method of the account. A passkey
+ * carries credentialId: the credential to name when a confirmation is asked
+ * for, also in a browser that did not create that passkey.
+ */
+export interface AccountIdentity {
+    identityId: string;
+    method: IdentityMethod;
+    credentialId?: string;
+    createdAt: string;
+}
+/** parseIdentityList accepts the closed answer of GET /v1/identities. */
+export declare function parseIdentityList(payload: unknown): AccountIdentity[];
+/**
+ * wallet_limits.set changes a linked wallet's limits (LinkedWallets.setLimits); its result kind is wallet_limits.
+ * session.authorize_requests enrolls a Mode C request key on a linked wallet (modeCLinked.ts); its result kind is
+ * request_grant, with the grant.
+ */
+export type LocalOperationKind = "identity.link" | "identity.unlink" | "session.revoke" | "service_grant.set" | "wallet_limits.set" | "session.authorize_requests";
+export type LocalResultKind = "identity" | "session" | "service_grant" | "wallet_limits" | "request_grant";
+export type LocalResultState = "active" | "revoked";
+export type ServiceReadScope = "wallet:read" | "operation:read" | "streams:read";
+export type ResultRecipient = {
+    type: "account" | "service";
+    id: string;
+};
+type LocalOperationCommon = {
+    owner_type: "account";
+    owner_id: string;
+    result_recipient?: ResultRecipient;
+};
+export type LocalOperationCreate = (LocalOperationCommon & {
+    kind: "identity.link";
+    payload: {
+        verified_identity_handle: string;
+    };
+}) | (LocalOperationCommon & {
+    kind: "identity.unlink";
+    payload: {
+        identity_id: string;
+    };
+}) | (LocalOperationCommon & {
+    kind: "session.revoke";
+    payload: {
+        session_id: string;
+    };
+}) | (LocalOperationCommon & {
+    kind: "service_grant.set";
+    wallet_id: string;
+    payload: {
+        service_principal_id: string;
+        enabled: boolean;
+        scopes: ServiceReadScope[];
+        external_ref?: string;
+    };
+}) | LinkedRequestGrantEnrollmentCreate;
+export type OperationDisplay = {
+    kind: "identity.link";
+    ownerId: string;
+    requesterId: string;
+    method: IdentityMethod;
+} | {
+    kind: "identity.unlink";
+    ownerId: string;
+    requesterId: string;
+    identityId: string;
+} | {
+    kind: "session.revoke";
+    ownerId: string;
+    requesterId: string;
+    sessionId: string;
+} | {
+    kind: "service_grant.set";
+    ownerId: string;
+    requesterId: string;
+    walletId: string;
+    servicePrincipalId: string;
+    enabled: boolean;
+    scopes: ServiceReadScope[];
+    externalRef?: string;
+} | WalletLimitsDisplay | LinkedEnrollmentDisplay;
+export interface LocalOperation {
+    id: string;
+    version: string;
+    kind: LocalOperationKind;
+    state: "awaiting_confirmation" | "authorized" | "succeeded" | "denied" | "canceled" | "expired";
+    effectState: "no_effect" | "known";
+    authorizationBasis: "" | "user_confirmed";
+    ownerType: "account";
+    ownerId: string;
+    requesterId: string;
+    walletId?: string;
+    requestFingerprint: string;
+    operationFingerprint: string;
+    display: OperationDisplay;
+    /** UTC RFC 3339 date-time string (source §2.2), not NumericDate seconds. */
+    createdAt: string;
+    /** UTC RFC 3339 date-time string (source §2.2), not NumericDate seconds. */
+    expiresAt: string;
+    confirmationLocation?: string;
+    resultKind?: LocalResultKind;
+    nextAction: NextAction;
+}
+export interface ConfirmationChallenge {
+    requestId: string;
+    challengeId: string;
+    publicKey: {
+        challenge: string;
+        rpId: string;
+        timeoutMs: number;
+        allowCredentials: [{
+            type: "public-key";
+            id: string;
+        }];
+        userVerification: "required";
+    };
+    confirmationLocation: string;
+    /** UTC RFC 3339 date-time string (source §2.2), not NumericDate seconds. */
+    expiresAt: string;
+}
+export interface LocalOperationResult {
+    requestId: string;
+    /** grant is present for the request_grant kind of a linked wallet's enrollment. */
+    result: {
+        kind: LocalResultKind;
+        targetId: string;
+        newVersion: string;
+        state: LocalResultState;
+        grant?: LinkedRequestGrantResult;
+    };
+}
+export declare function parseHostedIdentityFlow(payload: unknown, now: number): HostedIdentityFlow;
+export declare function parsePasskeyBootstrapResult(payload: unknown): PasskeyBootstrapResult;
+export declare function parseVerifiedIdentityResult(payload: unknown, now: number): VerifiedIdentityResult;
+export declare function parseIdentityFlowCallback(value: string, expectedRedirect: string): {
+    flowId: string;
+    state: string;
+    code: string;
+};
+export declare function validateLocalOperationCreate(value: LocalOperationCreate, expectedOwnerId: string): LocalOperationCreate;
+export declare function parseOperationEnvelope(payload: unknown): {
+    requestId: string;
+    operation: LocalOperation;
+};
+export declare function parseOperation(payload: unknown): LocalOperation;
+export declare function parseConfirmationChallenge(payload: unknown, now: number): ConfirmationChallenge;
+export declare function parseOperationConfirmationCallback(value: string, expectedRedirect: string): {
+    state: string;
+    operationId: string;
+};
+export declare function parseLocalOperationResult(payload: unknown): LocalOperationResult;
+export {};