Your first verified path

import {
  beginBind,
  parseBindCallback,
  finalizeBind,
  createGraphSigner,
  createTrustGraphSdk,
  generateBrowserGraphKey,
  signBrowserEdgeCertificate,
  signBrowserGraphRead,
  type PendingBind,
  type FinalizeBindInput,
  type FinalizeBindResult,
} from '@rebellion-systems/trust-graph-sdk/browser';
import {
  createZkVerifier,
  wotPathVerificationKey,
} from '@rebellion-systems/trust-graph-sdk/zk';

type BrowserKey = Awaited<ReturnType<typeof generateBrowserGraphKey>>;

// Application adapters: IndexedDB storage and verified device authority.
export interface BrowserApp {
  loadKey(): Promise<BrowserKey | null>;
  saveKey(key: BrowserKey): Promise<void>;
  loadPending(): Promise<PendingBind | null>;
  savePending(pending: PendingBind): Promise<void>;
  loadCompletion(): Promise<string | null>;
  saveCompletion(completionProof: string): Promise<void>;
  loadBound(): Promise<FinalizeBindResult | null>;
  saveBound(bound: FinalizeBindResult): Promise<void>;
  clearCeremony(): Promise<void>;
  refreshDeviceState: FinalizeBindInput['refreshDeviceState'];
}

export function createBrowserQuickstart(
  app: BrowserApp,
  pinnedAttestationJwks: unknown, // Trusted app configuration, not response data.
) {
  const serverOrigin = 'https://trust-staging.rebellion.systems';
  const graph = createTrustGraphSdk({ serverUrl: serverOrigin });

  async function start(recoverNodeId?: string): Promise<void> {
    if (await app.loadPending()) {
      throw new Error('Resume or explicitly clear the existing ceremony first');
    }
    let key = await app.loadKey();
    if (!key) {
      key = await generateBrowserGraphKey();
      await app.saveKey(key); // Durably persist before any navigation.
    }
    const pending = await beginBind({
      serverOrigin,
      appOrigin: window.location.origin,
      publicKeyJwk: key.publicKeyJwk,
      ...(recoverNodeId ? { recoverNodeId } : {}),
    });
    await app.savePending(pending);
    window.location.assign(pending.hostedUrl);
  }

  async function complete(): Promise<FinalizeBindResult> {
    const pending = await app.loadPending();
    const key = await app.loadKey();
    if (!pending || !key) throw new Error('Missing saved ceremony or device key');

    let completionProof = await app.loadCompletion();
    if (window.location.hash) {
      const completion = parseBindCallback(pending, window.location.href);
      completionProof = completion.completionProof;
      await app.saveCompletion(completionProof);
      history.replaceState(null, '', window.location.pathname);
    }
    if (!completionProof) throw new Error('Waiting for the AuthenSee callback');

    const signer = createGraphSigner({
      signatureFormat: 'ieee-p1363',
      randomUUID: () => crypto.randomUUID(),
      sign: async bytes => new Uint8Array(await crypto.subtle.sign(
        { name: 'ECDSA', hash: 'SHA-256' },
        key.privateKey,
        bytes as Uint8Array<ArrayBuffer>,
      )),
    });
    const bound = await finalizeBind(pending, {
      completionProof,
      publicKeyJwk: key.publicKeyJwk,
      persistPending: value => app.savePending(value),
      signRoot: record => signer.signFeedRecord(record),
      refreshDeviceState: value => app.refreshDeviceState(value),
    });
    await app.saveBound(bound);
    await app.clearCeremony();
    return bound;
  }

  async function vouchAndVerify(targetGraphNodeId: string) {
    const local = await app.loadKey();
    const bound = await app.loadBound();
    if (!local || !bound) throw new Error('Bind this device first');
    const state = await app.refreshDeviceState(bound.key);
    if (state.state !== 'approved' && state.state !== 'legacy') {
      throw new Error('This device is not currently authorized');
    }
    const { graphKeyId, graphNodeId } = bound.key;
    const certificate = {
      signerGraphKeyId: graphNodeId,
      subjectGraphKeyId: targetGraphNodeId,
      trust: 80,
      scope: 'identity' as const,
      createdAt: new Date().toISOString(),
      nonce: crypto.randomUUID(),
    };
    await graph.requestEdge({
      ...certificate,
      signingGraphKeyId: graphKeyId,
      signature: await signBrowserEdgeCertificate(local.privateKey, certificate),
    });

    const query = {
      sourceGraphKeyId: graphNodeId,
      targetGraphKeyId: targetGraphNodeId,
      policy: { scope: 'identity' as const, minTrust: 50, maxHops: 3 },
    };
    const authorization = await signBrowserGraphRead(local.privateKey, {
      operation: 'query-reachable', graphKeyId, graphNodeId, query,
    });
    const response = await graph.queryReachability({ ...query, authorization });
    const verifier = createZkVerifier();
    try {
      const result = await verifier.verifyAttestation({
        verificationKey: wotPathVerificationKey(),
        attestation: response.attestation,
        jwks: pinnedAttestationJwks,
        question: {
          sourceGraphKeyId: query.sourceGraphKeyId,
          targetGraphKeyId: query.targetGraphKeyId,
          ...query.policy,
        },
      });
      if (!result.verified) throw new Error(`Answer rejected: ${result.code}`);
      return result.verdict.reachable
        ? { label: 'Connected under your policy · proof verified', ...result.verdict }
        : { label: 'No path reported under your policy · signed report', ...result.verdict };
    } finally {
      await verifier.destroy();
    }
  }

  return { start, complete, vouchAndVerify };
}