@tempoxyz/id 0.0.0-stage → 0.0.1

package/src/api/lib/KeySigner.ts

@@ -0,0 +1,690 @@
+/**
+ * Signs an app's key authorization as the owner of the user's Tempo Account. The key acts for the
+ * account that it names, else the app's selected account, else the user's oldest. An owner with a
+ * server signer, such as a Privy wallet, signs on the server. A passkey signs only in the browser:
+ * on the approval page, {@link challenge} issues the key's digest as the passkey's challenge, and
+ * {@link sign} verifies the assertion over it. A sign-in with key signature on an app's page signs
+ * the digest with the assertion that signs the user in. Elsewhere its account refuses the key with
+ * `webauthn_required`. When the user skips a wallet.tempo passkey's upgrade, the passkey signs as
+ * its own account, and {@link unlinked} returns a passkey of the user's email that has not linked.
+ * @module
+ */
+import type { Context } from 'hono'
+import { Address } from 'ox'
+import type { KeyAuthorization as ox_KeyAuthorization } from 'ox/tempo'
+import { Account } from 'viem/tempo'
+import { env } from 'void/env'
+import { Authentication } from 'webauthx/server'
+import * as z from 'zod'
+import * as Authorize from '../../internal/Authorize.js'
+import * as ConfigurableAccount from '../../internal/ConfigurableAccount.js'
+import type { Env } from '../../internal/Env.js'
+import * as ErrorResponse from '../../internal/ErrorResponse.js'
+import * as Log from '../../internal/Log.js'
+import * as KeyAuthorization from '../../internal/KeyAuthorization.js'
+import * as Owner from '../../internal/Owner.js'
+import * as Passkey from '../../internal/Passkey.js'
+import * as RateLimit from '../../internal/RateLimit.js'
+import * as Realm from '../../internal/Realm.js'
+import * as TempoAccount from '../../internal/TempoAccount.js'
+import * as Timing from '../../internal/Timing.js'
+import * as AccountStep from './AccountStep.js'
+import * as Configure from './Configure.js'
+import { db } from './Database.js'
+
+export namespace schema {
+  /** Why approval cannot sign a key, as {@link preview} returns it. */
+  export const refusal = z
+    .enum([
+      'foreign_account',
+      'no_account',
+      'passkey',
+      'unavailable',
+      'upgrade',
+    ])
+    .meta({
+      description:
+        "Why approval cannot sign the key: the key names another user's account (`foreign_account`), the user holds no account and none can be created (`no_account`), a passkey that this page cannot use owns the account (`passkey`), the accounts could not be read (`unavailable`), or the account must upgrade first (`upgrade`). Absent when approval can sign it.",
+      examples: ['passkey'],
+    })
+}
+
+/**
+ * Issues the digest of `key` as the challenge of a signature by `owner`'s passkey, for the user with
+ * `userId`, and returns the request options for `navigator.credentials.get()`. The options name only
+ * that passkey, and require user verification.
+ */
+export async function challenge(
+  c: Timing.measure.Context,
+  options: challenge.Options,
+) {
+  const { account, clientId, key, owner, userId } = options
+  // `resolve` returns a passkey owner only with its credential.
+  const credential = owner.credential!
+  const digest = KeyAuthorization.digest({
+    account: Owner.configured(owner),
+    key,
+  })
+  await Timing.measure(
+    c,
+    Passkey.requestSignature(db, {
+      account,
+      clientId,
+      credential,
+      digest,
+      userId,
+    }),
+    'Passkey.requestSignature',
+  )
+  return Authentication.getOptions({
+    challenge: digest,
+    credentialId: credential.id,
+    rpId: credential.rpId,
+    userVerification: 'required',
+  }).options
+}
+
+export declare namespace challenge {
+  type Options = {
+    /** The account that the key acts for. */
+    account: `0x${string}`
+    /** The client ID of the app that requests the key. */
+    clientId: string
+    /** The key authorization whose digest the passkey signs. */
+    key: KeyAuthorization.Key
+    /** The account's passkey owner, as `resolve` returns it with `passkey`. */
+    owner: Owner.Owner
+    /** The signed-in user's ID. */
+    userId: string
+  }
+}
+
+/**
+ * Returns what an approval page shows of a key before the user decides: the account that approval
+ * signs for, the user's accounts in the app's realms, and why approval cannot sign it, if it cannot.
+ * Without `account`, it is the app's selected account, else the user's oldest. The owners' lookup can call every realm's
+ * Privy app, so it counts against the user's `ACCOUNT_LIMIT`, as `GET /v1/account` does. A spent
+ * limit or a failed read, such as during a Privy outage, returns `unavailable`. A user who holds no
+ * account can approve when the app's first realm creates one on approval, unless a wallet.tempo
+ * passkey of the user's email waits for its upgrade, which returns `upgrade`.
+ */
+export async function preview(
+  c: Context<Env>,
+  options: preview.Options,
+): Promise<preview.ReturnType> {
+  const { clientId, sessionId, userId } = options
+  const chainId =
+    options.chainId === undefined ? undefined : Number(options.chainId)
+  const read = await (async () => {
+    const admitted = await RateLimit.count(c, {
+      binding: 'ACCOUNT_LIMIT',
+      key: userId,
+    })
+    if (!admitted) return undefined
+    try {
+      const owners = await Timing.measure(
+        c,
+        AccountStep.held(c, { chainId, clientId, userId }),
+        'AccountStep.held',
+      )
+      const signing = await Timing.measure(
+        c,
+        resolve(c, {
+          account: options.account,
+          chainId,
+          clientId,
+          cookie: c.req.header('cookie'),
+          owners,
+          // The approval page runs the passkey step.
+          passkey: true,
+          sessionId,
+          userId,
+        }),
+        'KeySigner.resolve',
+      )
+      return { owners, signing }
+    } catch (error) {
+      Log.warn(c, {
+        error,
+        fields: { clientId },
+        message: "An approval page's account owners failed to load.",
+      })
+      return undefined
+    }
+  })()
+  const signing = read?.signing
+
+  // A wallet.tempo passkey of the user's email becomes their account through its upgrade, so approval
+  // creates no account beside it, and waits for the upgrade instead.
+  const waits =
+    signing instanceof Authorize.RejectedError
+      ? await Timing.measure(
+          c,
+          AccountStep.awaitsUpgrade(c, {
+            clientId,
+            email: options.email,
+            userId,
+          }),
+          'AccountStep.awaitsUpgrade',
+        )
+      : false
+  // A user who holds no account receives the first one on approval, when the app's first realm can
+  // create it.
+  const creates =
+    signing instanceof Authorize.RejectedError && !waits
+      ? await Timing.measure(
+          c,
+          AccountStep.creates(c, { clientId }),
+          'AccountStep.creates',
+        )
+      : false
+  const account = (() => {
+    if (!signing) return options.account
+    if (
+      signing instanceof KeyAuthorization.WebAuthnRequiredError ||
+      signing instanceof ConfigurableAccount.UpgradeRequiredError
+    )
+      return signing.response.meta?.account as `0x${string}` | undefined
+    if (signing instanceof ErrorResponse.ResponseError) return options.account
+    return signing.account
+  })()
+  const refusal = ((): z.output<typeof schema.refusal> | undefined => {
+    if (!signing) return 'unavailable'
+    if (signing instanceof TempoAccount.ForeignAccountError)
+      return 'foreign_account'
+    // A passkey signs only at its own relying party, which may not cover this page.
+    if (signing instanceof KeyAuthorization.WebAuthnRequiredError)
+      return 'passkey'
+    if (signing instanceof ConfigurableAccount.UpgradeRequiredError || waits)
+      return 'upgrade'
+    if (signing instanceof Authorize.RejectedError && !creates)
+      return 'no_account'
+    return undefined
+  })()
+  const accounts = read ? read.owners.map(TempoAccount.serialize) : []
+  return { account, accounts, refusal }
+}
+
+export declare namespace preview {
+  type Options = {
+    /** The account that the key names, if any. */
+    account?: `0x${string}` | undefined
+    /** The ID of the chain that the key acts on, if any, whose view of the accounts the page shows. */
+    chainId?: bigint | number | undefined
+    /** The client ID of the app that requests the key. */
+    clientId: string
+    /** The signed-in user's verified email, whose wallet.tempo passkey can wait for its upgrade. */
+    email: string
+    /** The ID of the signed-in session, which bounds the account step's selection. */
+    sessionId: string
+    /** The signed-in user's ID. */
+    userId: string
+  }
+
+  type ReturnType = {
+    /** The account that approval signs for. Absent for a user who holds no account. */
+    account: `0x${string}` | undefined
+    /**
+     * The user's accounts in the app's realms, oldest first. Empty when the limit is spent or the
+     * read fails.
+     */
+    accounts: readonly TempoAccount.TempoAccount[]
+    /** Why approval cannot sign the key. Absent when it can. */
+    refusal: z.output<typeof schema.refusal> | undefined
+  }
+}
+
+/**
+ * Returns the account that the key acts for and its owner: the account that `account` names, else
+ * the one that the `Cookie` header selects for the app within the session, else the user's oldest
+ * in the app's realms. With `signInCredential`, the account that the passkey of the sign-in with
+ * key signature owns comes before the selected one. With `create`, a user who holds no account and
+ * names none first receives a Privy-owned account, as `POST /v1/account` creates it. Returns a
+ * refusal when `account` is not the user's, when the user holds no account, when a passkey owns
+ * the account, unless it is the passkey of the sign-in with key signature, or when a wallet.tempo
+ * passkey's account waits for its upgrade, unless `skipUpgrade` is set.
+ */
+export async function resolve(
+  c: Context<Env>,
+  options: resolve.Options,
+): Promise<resolve.ReturnType | ErrorResponse.Instance<typeof resolve.errors>> {
+  const { clientId, cookie, sessionId, userId } = options
+  const chainId =
+    options.chainId === undefined ? undefined : Number(options.chainId)
+  // A named account is one the user already holds, so its request creates none.
+  const owners =
+    options.owners ??
+    (options.create && !options.account
+      ? await Timing.measure(
+          c,
+          AccountStep.create(c, {
+            chainId,
+            clientId,
+            email: options.email,
+            userId,
+          }),
+          'AccountStep.create',
+        )
+      : await Timing.measure(
+          c,
+          AccountStep.held(c, { chainId, clientId, userId }),
+          'AccountStep.held',
+        ))
+  const listed = owners.map(TempoAccount.serialize)
+
+  const named = options.account
+  // The passkey that signed the sign-in selects the account that it owns.
+  const tapped = owners.find(
+    (entry) =>
+      options.signInCredential !== undefined &&
+      entry.credential?.id === options.signInCredential,
+  )
+  const selected = named
+    ? undefined
+    : ((tapped && TempoAccount.serialize(tapped).address) ??
+      AccountStep.find(
+        listed,
+        AccountStep.selected({ clientId, cookie, sessionId }),
+      )?.address)
+  // A user who chose no account, and holds several, signs only on a page that shows the account.
+  if (options.single && !named && !selected && listed.length > 1)
+    return new Authorize.RejectedError({
+      description:
+        "Several Tempo Accounts: the user holds more than one account in the app's realms and chose none. Choose the account on the account step, or name it in `key_authorization.account`.",
+    })
+  const account = (() => {
+    if (named) return AccountStep.find(listed, named)?.address
+    return selected ?? listed[0]?.address
+  })()
+  if (named && !account)
+    return new TempoAccount.ForeignAccountError({
+      account: named,
+      field: 'key_authorization.account',
+    })
+  const found = account
+    ? owners.find(
+        (entry) =>
+          TempoAccount.serialize(entry).address.toLowerCase() ===
+          account.toLowerCase(),
+      )
+    : undefined
+  if (!account || !found)
+    return new Authorize.RejectedError({
+      description: options.create
+        ? "No Tempo Account: the user holds no account in the app's realms, and the app's first realm has no Privy app to create one. Authorize without `key_authorization`."
+        : "No Tempo Account: the user holds no account in the app's realms, so no owner signs the key. Create the account with `POST /v1/account`, or authorize without `key_authorization`.",
+    })
+  // On a chain whose accounts are configurable, the configurable account signs, never a root key. A
+  // wallet.tempo passkey's account signs nothing there until its upgrade, unless the user skips the
+  // upgrade, and the passkey then signs as its own account until the upgrade.
+  if (
+    found.linked &&
+    !found.configurable &&
+    !options.skipUpgrade &&
+    ConfigurableAccount.on({ chainId, env })
+  )
+    return new ConfigurableAccount.UpgradeRequiredError({ account })
+  const owner = Owner.on(found, { chainId })
+  // A passkey signs only in the browser: on a page that shows the key, at its relying party, or in
+  // the sign-in with key signature that it signed. A sign-in with key signature signs only as the
+  // key that acts as the account, since its digest binds no configuration.
+  if (
+    !owner.signer &&
+    !(options.passkey && signsHere(owner, { page: options.page })) &&
+    !(
+      options.signInCredential !== undefined &&
+      owner === found &&
+      owner.credential?.id === options.signInCredential
+    )
+  )
+    return new KeyAuthorization.WebAuthnRequiredError({ account })
+  return { account, owner }
+}
+
+export namespace resolve {
+  export type Options = {
+    /** The account that the request names, if any. */
+    account?: `0x${string}` | undefined
+    /**
+     * The ID of the chain that the key acts on. On a chain whose accounts are configurable, the
+     * configurable account signs, through one of its owners. Absent, the key that acts as the
+     * account signs.
+     */
+    chainId?: bigint | number | undefined
+    /** The client ID of the app that requests the key. */
+    clientId: string
+    /** The request's `Cookie` header, which holds the account step's selection. */
+    cookie: string | undefined
+    /**
+     * Whether a user who holds no account and names none receives a first account. An approval on
+     * Tempo ID's own page sets it, and so does a sign-in that carries the authorization request.
+     * Defaults to `false`.
+     */
+    create?: boolean | undefined
+    /** The user's verified email, when the caller holds it, which `create` reads. */
+    email?: string | undefined
+    /**
+     * The owners of the user's accounts in the app's realms, as `AccountStep.held` returns them, when
+     * the caller already read them. Takes the place of the read, and of `create`.
+     */
+    owners?: readonly Owner.Owner[] | undefined
+    /**
+     * The origin of the app's page that signs with a passkey, with `passkey`. The passkey's relying
+     * party must then cover that origin too. Absent for Tempo ID's own page.
+     */
+    page?: string | undefined
+    /**
+     * Whether the caller signs with a passkey in the browser, as the approval page does. A passkey
+     * owner whose relying party covers Tempo ID's origin then resolves, in place of
+     * `webauthn_required`. Defaults to `false`.
+     */
+    passkey?: boolean | undefined
+    /** The ID of the signed-in session, which bounds the selection. */
+    sessionId: string
+    /**
+     * The credential ID of the passkey whose sign-in assertion signed the key's digest, if any.
+     * That passkey's account resolves in place of `webauthn_required`, and comes before the
+     * selected one.
+     */
+    signInCredential?: string | undefined
+    /**
+     * Whether a user who names no account, selected none, and holds several is refused, in place of
+     * the oldest account. A grant that shows no account sets it. Defaults to `false`.
+     */
+    single?: boolean | undefined
+    /**
+     * Whether a linked wallet.tempo passkey's account that is not configurable on the key's chain
+     * resolves, in place of `upgrade_required`. The passkey then signs as its own account, as on a
+     * chain whose accounts are not configurable, and the key stops working on that chain once the
+     * account upgrades. The approval page sets it when the user skips the upgrade. Defaults to
+     * `false`.
+     */
+    skipUpgrade?: boolean | undefined
+    /** The signed-in user's ID. */
+    userId: string
+  }
+
+  export type ReturnType = {
+    /** The account that the key acts for. */
+    account: `0x${string}`
+    /**
+     * The account's owner, which signs the key: on a chain whose accounts are configurable, the
+     * configurable view that `Owner.on` returns.
+     */
+    owner: Owner.Owner
+  }
+
+  /** The refusals `resolve` returns. Its return type admits no other. */
+  export const errors = [
+    ...AccountStep.create.errors,
+    ...AccountStep.held.errors,
+    Authorize.RejectedError,
+    ConfigurableAccount.UpgradeRequiredError,
+    KeyAuthorization.WebAuthnRequiredError,
+    TempoAccount.ForeignAccountError,
+  ] as const
+}
+
+/**
+ * Signs `key` as `owner`, the owner of `account`, and returns the signed authorization in the node's
+ * RPC format. A passkey owner signs with `assertion`, over the challenge that {@link challenge} or
+ * `Passkey.requestSignature` issued for the same user, app, account, passkey, and key, at `origin`. Returns
+ * `KeyAuthorization.WebAuthnRequiredError` for a passkey owner without an assertion, and
+ * `Passkey.WebAuthnRejectedError` for an assertion that does not verify.
+ */
+export async function sign(
+  c: Context<Env>,
+  options: sign.Options,
+): Promise<sign.ReturnType | ErrorResponse.Instance<typeof sign.errors>> {
+  const { account, assertion, key, owner } = options
+  if (!owner.signer) {
+    if (!assertion || !owner.credential)
+      return new KeyAuthorization.WebAuthnRequiredError({ account })
+    const credential = owner.credential
+    // A sign-in's challenge was the key's digest, so its assertion verifies over that digest with
+    // no stored signature challenge, and is recorded as spent once it verifies.
+    if (options.challenge === 'sign-in') {
+      const digest = KeyAuthorization.digest({
+        account: Owner.configured(owner),
+        key,
+      })
+      const verified =
+        assertion.id === credential.id &&
+        Passkey.verify(assertion, {
+          challenge: digest,
+          origin: options.origin ?? new URL(env.URL).origin,
+          publicKey: credential.publicKey,
+          rpId: credential.rpId,
+        })
+      if (
+        !verified ||
+        !(await Timing.measure(
+          c,
+          Passkey.spendSignature(db, {
+            authenticatorData: assertion.metadata.authenticatorData,
+            expiry: key.expiry,
+            signature: assertion.signature,
+          }),
+          'Passkey.spendSignature',
+        ))
+      )
+        return new Passkey.WebAuthnRejectedError()
+      return await Timing.measure(
+        c,
+        KeyAuthorization.signWithAssertion(assertion, {
+          account: Owner.configured(owner),
+          key,
+          publicKey: credential.publicKey,
+        }),
+        'KeyAuthorization.signWithAssertion',
+      )
+    }
+    // The challenge is spent before any other check, so a refused assertion cannot be tried again.
+    const challenge = await Timing.measure(
+      c,
+      Passkey.takeSignature(db, {
+        account,
+        authenticatorData: assertion.metadata.authenticatorData,
+        clientId: options.clientId,
+        clientDataJSON: assertion.metadata.clientDataJSON,
+        credentialId: assertion.id,
+        expiry: key.expiry,
+        signature: assertion.signature,
+        userId: options.userId,
+        verify: (challenge) =>
+          challenge.account === account.toLowerCase() &&
+          challenge.clientId === options.clientId &&
+          challenge.credential.id === credential.id &&
+          challenge.credential.publicKey === credential.publicKey &&
+          assertion.id === credential.id &&
+          // The repeated request names the key that the passkey signs, so its signature reaches
+          // only a request for that key.
+          challenge.digest ===
+            KeyAuthorization.digest({
+              account: Owner.configured(owner),
+              key,
+            }) &&
+          Passkey.verify(assertion, {
+            challenge: challenge.digest,
+            origin: options.origin ?? new URL(env.URL).origin,
+            publicKey: credential.publicKey,
+            rpId: credential.rpId,
+          }),
+      }),
+      'Passkey.takeSignature',
+    )
+    if (!challenge) return new Passkey.WebAuthnRejectedError()
+    return await Timing.measure(
+      c,
+      KeyAuthorization.signWithAssertion(assertion, {
+        account: Owner.configured(owner),
+        key,
+        publicKey: credential.publicKey,
+      }),
+      'KeyAuthorization.signWithAssertion',
+    )
+  }
+
+  const signer = await Timing.measure(
+    c,
+    owner.signer(c, { auth: c.var.auth }),
+    'Owner.signer',
+  )
+  return await Timing.measure(
+    c,
+    KeyAuthorization.sign(signer, { key }),
+    'KeyAuthorization.sign',
+  )
+}
+
+export namespace sign {
+  export type Options = {
+    /** The account that the key acts for. */
+    account: `0x${string}`
+    /** The passkey's assertion over its challenge, for a passkey owner. */
+    assertion?: Passkey.Assertion | undefined
+    /**
+     * Where the challenge of `assertion` came from: `sign-in`, a sign-in with key signature whose challenge was
+     * the key's digest, or `stored`, a signature challenge of {@link challenge}. Defaults to
+     * `stored`.
+     */
+    challenge?: 'sign-in' | 'stored' | undefined
+    /** The client ID of the app that requests the key. */
+    clientId: string
+    /** The key authorization to sign, which the flow's checks accept. */
+    key: KeyAuthorization.Key
+    /**
+     * The origin that the assertion reports: the app's page of a sign-in with key signature. Defaults to Tempo
+     * ID's own.
+     */
+    origin?: string | undefined
+    /** The account's owner. */
+    owner: Owner.Owner
+    /** The signed-in user's ID. */
+    userId: string
+  }
+
+  /** The signed authorization, in the node's RPC format. */
+  export type ReturnType = ox_KeyAuthorization.Rpc
+
+  /** The refusals `sign` returns. Its return type admits no other. */
+  export const errors = [
+    KeyAuthorization.WebAuthnRequiredError,
+    Passkey.WebAuthnRejectedError,
+  ] as const
+}
+
+/**
+ * Returns a wallet.tempo passkey of `email`, the signed-in user's, that has not linked, as the owner
+ * that signs a key when the user skips its upgrade: the passkey `credentialId`, else the first. The
+ * passkey signs as its own account, at the `default` realm's relying party, which wallet.tempo
+ * shares. `link` links it to the user. Returns `undefined` when the app's realms leave out the
+ * `default` realm, or when no such passkey exists.
+ */
+export async function unlinked(
+  c: Context<Env>,
+  options: unlinked.Options,
+): Promise<unlinked.ReturnType | undefined> {
+  const { clientId, credentialId, email, userId } = options
+  const realms = await Timing.measure(
+    c,
+    Configure.reach(c, { clientId }),
+    'Configure.reach',
+  )
+  const realm = realms.find((entry) => entry.id === Realm.defaultId)
+  const relyingParty = realm
+    ? Passkey.relyingParty([realm], { origin: env.URL })
+    : undefined
+  if (!realm || !relyingParty) return undefined
+
+  const listed = await Timing.measure(
+    c,
+    Configure.unlinked(c, { email }),
+    'Configure.unlinked',
+  )
+  const entry =
+    credentialId === undefined
+      ? listed[0]
+      : listed.find((item) => item.credentialId === credentialId)
+  if (!entry) return undefined
+
+  const { rpId } = relyingParty
+  const account = Address.checksum(entry.address as Address.Address)
+  const credential = {
+    id: entry.credentialId,
+    publicKey: entry.publicKey,
+    rpId,
+  }
+  return {
+    account,
+    // A passkey that links to another user, in a race, refuses the key.
+    link: async () => {
+      const linked = await Timing.measure(
+        c,
+        Passkey.link(db, {
+          credential: entry,
+          id: credential.id,
+          rpId,
+          userId,
+        }),
+        'Passkey.link',
+      )
+      TempoAccount.forget(c)
+      return linked === userId
+        ? undefined
+        : new TempoAccount.ForeignAccountError({ account, field: 'passkey' })
+    },
+    owner: Owner.from({
+      account: Account.fromConfig({
+        owners: [Account.fromWebAuthnP256(credential, { rpId })],
+      }),
+      createdAt:
+        entry.createdAt === null ? new Date() : new Date(entry.createdAt),
+      credential,
+      linked: true,
+      realm,
+      signer: undefined,
+      type: 'webAuthn',
+    }),
+  }
+}
+
+export namespace unlinked {
+  export type Options = {
+    /** The client ID of the app that requests the key, whose realms must include `default`. */
+    clientId: string
+    /**
+     * The credential ID of the passkey, such as that of the assertion that signs the key. Absent,
+     * the first passkey that wallet.tempo lists.
+     */
+    credentialId?: string | undefined
+    /** The signed-in user's verified email, which wallet.tempo lists the passkeys of. */
+    email: string
+    /** The signed-in user's ID. */
+    userId: string
+  }
+
+  export type ReturnType = resolve.ReturnType & {
+    /**
+     * Links the passkey to the user. Run it only once the passkey's assertion over the key verifies,
+     * which proves that the user holds the passkey, as an upgrade's assertion does. Returns
+     * `foreign_account` when the passkey linked to another user first.
+     */
+    link: () => Promise<TempoAccount.ForeignAccountError | undefined>
+  }
+
+  /** The refusal that `link` returns. */
+  export const errors = [TempoAccount.ForeignAccountError] as const
+}
+
+/**
+ * Returns whether `owner`'s passkey signs at Tempo ID's origin, and at `page` when given: its relying
+ * party ID is the host of each origin or a registrable suffix of it, as WebAuthn requires.
+ */
+function signsHere(owner: Owner.Owner, options: { page?: string | undefined }) {
+  if (!owner.credential) return false
+  return (
+    Passkey.relyingParty([owner.realm], { origin: env.URL, page: options.page })
+      ?.rpId === owner.credential.rpId
+  )
+}