Something went wrong. Try again.
Web frontend and supporting services for lance.blue
Something went wrong. Try again.
4.8 kB · 116 lines
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117/** * Who a `/profile/<...>` address names. * * The address takes either form — a handle, or a fully qualified DID — and * both have to end up at the same place, so this resolves in whichever * direction it is handed and answers with both halves. * * The DID document is the authority in both directions, and nothing here * trusts a resolver: * * - A handle is looked up through `com.atproto.identity.resolveHandle`, * which does live resolution (DNS, then `/.well-known/atproto-did`) * rather than an index lookup. Then the DID it answered with is fetched * and its `alsoKnownAs` has to name the handle that was asked for. A * resolver that lied is caught by that check, which is the reason this * can use somebody else's resolver at all. * - A DID is fetched first, and the handle its `alsoKnownAs` claims is * resolved back. A claim nobody can confirm is dropped rather than * shown: a handle is rented, and the account that used to hold one is * not the account that holds it now. * * A null handle is therefore never an error. It means the account has no * handle we are willing to put in front of a reader, and the DID is what is * shown instead — the same rule profile.ts's `accountName` already follows * for the signed-in account. */
import { didDocument } from "./pds";
/** * The resolver a handle is put to. * * Somebody else's, and it does not have to be honest: every answer is * checked against the DID document before it is used. The public appview is * the one this site already talks to (see avatars.ts), so it is the one with * a cache entry and a warm connection by the time a profile page asks. */const RESOLVER = "https://public.api.bsky.app";
/** An account, as far as a page is allowed to state it. */export interface Actor { readonly did: string; /** Null where no handle resolves back to this DID. */ readonly handle: string | null;}
/** Whether this segment of the address is a DID rather than a handle. */export function isDid(actor: string): boolean { return actor.startsWith("did:");}
/** * The account an address names, or null where nothing does. * * Null is the not-found answer, and it covers a handle nobody holds as well * as a DID with no document. It is not an error: a mistyped address is an * ordinary thing for a page to be asked for, and the page says so itself. */export async function resolveActor(actor: string): Promise<Actor | null> { const trimmed = actor.trim().replace(/^@/, ""); if (trimmed === "") return null; try { return isDid(trimmed) ? await fromDid(trimmed) : await fromHandle(trimmed.toLowerCase()); } catch (error: unknown) { console.warn(`identity: ${trimmed} did not resolve`, error); return null; }}
/** A DID, and whatever handle it can prove. */async function fromDid(did: string): Promise<Actor | null> { const doc = await didDocument(did); const claimed = claimedHandle(doc); if (!claimed) return { did, handle: null }; const confirmed = await resolveHandle(claimed); return { did, handle: confirmed === did ? claimed : null };}
/** A handle, and the DID it resolves to — if that DID claims it back. */async function fromHandle(handle: string): Promise<Actor | null> { const did = await resolveHandle(handle); if (!did) return null; const doc = await didDocument(did); // The handle the document claims, not the one that was asked for: they are // the same string in the ordinary case, and where they are not, the // document is the one to believe. return { did, handle: claimedHandle(doc) === handle ? handle : null };}
/** The handle a DID document claims, lower-cased, or null where it claims none. */function claimedHandle(doc: { alsoKnownAs?: unknown }): string | null { const names = Array.isArray(doc.alsoKnownAs) ? doc.alsoKnownAs : []; for (const name of names) { if (typeof name === "string" && name.startsWith("at://")) { const handle = name.slice("at://".length).toLowerCase(); if (handle !== "") return handle; } } return null;}
/** The DID a handle resolves to, or null where it resolves to nothing. */async function resolveHandle(handle: string): Promise<string | null> { const url = `${RESOLVER}/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`; const response = await fetch(url); // 400 is what an unresolvable handle answers, and it is an answer rather // than a failure. Anything else is the resolver having a bad day, and is // worth throwing so the caller logs it. if (response.status === 400) return null; if (!response.ok) throw new Error(`resolveHandle answered ${response.status}`); const body = (await response.json()) as { did?: unknown }; return typeof body.did === "string" ? body.did : null;}