@metalabel/dfos-protocol 0.44.0 → 0.46.0

package/dist/chunk-JVSC67DC.js

@@ -0,0 +1,981 @@
+import {
+  ED25519_PUB_MULTICODEC,
+  decodeMultikey,
+  encodeEd25519Multikey
+} from "./chunk-IDVYITX7.js";
+import {
+  base64urlDecode,
+  base64urlEncode,
+  importEd25519Keypair,
+  isValidEd25519Signature,
+  sha256,
+  signPayloadEd25519
+} from "./chunk-4LG2GEB2.js";
+
+// src/key-proof/role-set.ts
+var KEY_ROLES = ["auth", "assert", "controller"];
+var isKeyRole = (value) => KEY_ROLES.includes(value);
+var serializeRoleSet = (roles) => {
+  const present = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (!isKeyRole(role)) {
+      throw new Error(`invalid role set: unknown role ${JSON.stringify(role)}`);
+    }
+    present.add(role);
+  }
+  if (present.size === 0) throw new Error("invalid role set: must name at least one role");
+  return KEY_ROLES.filter((role) => present.has(role)).join(",");
+};
+var parseRoleSet = (value) => {
+  const parts = value.split(",");
+  const roles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    if (!isKeyRole(part) || seen.has(part)) return null;
+    seen.add(part);
+    roles.push(part);
+  }
+  if (roles.join(",") !== KEY_ROLES.filter((role) => seen.has(role)).join(",")) return null;
+  return roles;
+};
+var isCanonicalRoleSet = (value) => parseRoleSet(value) !== null;
+var roleSetCovers = (value, role) => parseRoleSet(value)?.includes(role) ?? false;
+
+// src/key-proof/key-proof.ts
+var KEY_ADD_JWS_TYP = "did:dfos:key-add";
+var MAX_KEY_PROOF_SIZE = 4096;
+var DEFAULT_KEY_PROOF_SKEW_SECONDS = 300;
+var KeyProofVerifyError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "KeyProofVerifyError";
+    this.reason = reason;
+  }
+};
+var invalid = (reason, message) => new KeyProofVerifyError(reason, `invalid key proof: ${message}`);
+var encoder = new TextEncoder();
+var KEY_PROOF_MEMBERS = [
+  "nonce",
+  "audience",
+  "did",
+  "roleSet",
+  "prevCID",
+  "publicKeyMultibase",
+  "timestamp"
+];
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+var WHOLE_SECOND_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.000Z$/;
+var PROTOCOL_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var validateKeyProofPayload = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw invalid("schema", "expected a JSON object");
+  }
+  const raw = value;
+  for (const member of Object.keys(raw)) {
+    if (!KEY_PROOF_MEMBERS.includes(member)) {
+      throw invalid("schema", `unknown member ${JSON.stringify(member)} \u2014 the payload is closed`);
+    }
+  }
+  for (const member of KEY_PROOF_MEMBERS) {
+    if (typeof raw[member] !== "string" || raw[member] === "") {
+      throw invalid("schema", `${member} must be a non-empty string`);
+    }
+    if (LONE_SURROGATE.test(raw[member])) {
+      throw invalid("schema", `${member} must be well-formed Unicode`);
+    }
+  }
+  const nonce = raw["nonce"];
+  const audience = raw["audience"];
+  const did = raw["did"];
+  const roleSet = raw["roleSet"];
+  const prevCID = raw["prevCID"];
+  const publicKeyMultibase = raw["publicKeyMultibase"];
+  const timestamp = raw["timestamp"];
+  if (audience !== audience.toLowerCase() || /[\s/\\?#]/.test(audience)) {
+    throw invalid("schema", "audience must be a lowercase authority, without a scheme or path");
+  }
+  if (!isCanonicalRoleSet(roleSet)) {
+    throw invalid(
+      "schema",
+      "roleSet must be a canonical, non-empty subset of auth,assert,controller in that order"
+    );
+  }
+  const parsedMs = WHOLE_SECOND_TIMESTAMP.test(timestamp) ? Date.parse(timestamp) : Number.NaN;
+  if (!Number.isFinite(parsedMs) || new Date(parsedMs).toISOString() !== timestamp) {
+    throw invalid("schema", "timestamp must be ISO-8601 UTC whole-second .000Z");
+  }
+  return { nonce, audience, did, roleSet, prevCID, publicKeyMultibase, timestamp };
+};
+var keyProofSigningInput = (payload) => encoder.encode(JSON.stringify(keyProofPayloadObject(validateKeyProofPayload(payload))));
+var keyProofPayloadObject = (payload) => ({
+  nonce: payload.nonce,
+  audience: payload.audience,
+  did: payload.did,
+  roleSet: payload.roleSet,
+  prevCID: payload.prevCID,
+  publicKeyMultibase: payload.publicKeyMultibase,
+  timestamp: payload.timestamp
+});
+var bytesEqual = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+var normalizeTimestamp = (ms) => new Date(Math.floor(ms / 1e3) * 1e3).toISOString();
+var signKeyProof = async (input) => {
+  if (input.typ === "") {
+    throw new Error("invalid key proof: typ must be a registered purpose value");
+  }
+  const { publicKey } = importEd25519Keypair(input.privateKey);
+  let timestamp;
+  if (input.timestamp === void 0) {
+    timestamp = normalizeTimestamp(input.now ? input.now() : Date.now());
+  } else {
+    const ms = Date.parse(input.timestamp);
+    if (!PROTOCOL_TIMESTAMP.test(input.timestamp) || !Number.isFinite(ms) || new Date(ms).toISOString() !== input.timestamp) {
+      throw new Error(`invalid key proof: unparseable timestamp: ${input.timestamp}`);
+    }
+    timestamp = normalizeTimestamp(ms);
+  }
+  const payload = validateKeyProofPayload({
+    nonce: input.nonce,
+    audience: input.audience,
+    did: input.did,
+    roleSet: input.roleSet,
+    prevCID: input.prevCID,
+    publicKeyMultibase: encodeEd25519Multikey(publicKey),
+    timestamp
+  });
+  const headerB64 = base64urlEncode(JSON.stringify({ alg: "EdDSA", typ: input.typ }));
+  const payloadB64 = base64urlEncode(keyProofSigningInput(payload));
+  const signingInput = `${headerB64}.${payloadB64}`;
+  const signature = signPayloadEd25519(encoder.encode(signingInput), input.privateKey);
+  const proof = `${signingInput}.${base64urlEncode(signature)}`;
+  if (proof.length > MAX_KEY_PROOF_SIZE) {
+    throw new Error(`key proof exceeds max size: ${proof.length} > ${MAX_KEY_PROOF_SIZE}`);
+  }
+  return { proof, payload };
+};
+var decodeKeyProof = (jws, expectedTyp) => {
+  if (jws.length > MAX_KEY_PROOF_SIZE) {
+    throw invalid("size", `envelope exceeds max size: ${jws.length} > ${MAX_KEY_PROOF_SIZE}`);
+  }
+  const parts = jws.split(".");
+  if (parts.length !== 3) throw invalid("header", "failed to decode JWS");
+  const [headerB64, payloadB64, signatureB64] = parts;
+  let header;
+  try {
+    const decoded = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(base64urlDecode(headerB64))
+    );
+    if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+      throw new Error("protected header must be an object");
+    }
+    header = decoded;
+  } catch (err) {
+    throw invalid("header", err instanceof Error ? err.message : "failed to decode header");
+  }
+  if (header["alg"] !== "EdDSA") {
+    throw invalid("header", `unsupported algorithm: ${String(header["alg"])}`);
+  }
+  if ("crit" in header) throw invalid("header", "crit header is not supported");
+  for (const member of ["jwk", "jku", "x5c", "x5u"]) {
+    if (member in header) {
+      throw invalid("header", `${member} header is not allowed (the key rides in the payload)`);
+    }
+  }
+  if ("kid" in header) {
+    throw invalid("header", "kid must be absent \u2014 the candidate key is in no chain");
+  }
+  const typ = header["typ"];
+  if (typeof typ !== "string" || typ !== expectedTyp) {
+    throw invalid("header", `invalid typ: expected ${expectedTyp}, got ${String(typ)}`);
+  }
+  let payload;
+  try {
+    const payloadBytes = base64urlDecode(payloadB64);
+    const source = new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes);
+    payload = validateKeyProofPayload(JSON.parse(source));
+    if (!bytesEqual(keyProofSigningInput(payload), payloadBytes)) {
+      throw invalid("schema", "payload is not the canonical signing input for its members");
+    }
+  } catch (err) {
+    if (err instanceof KeyProofVerifyError) throw err;
+    throw invalid("schema", err instanceof Error ? err.message : "payload is not valid UTF-8 JSON");
+  }
+  return { payload, headerB64, payloadB64, signatureB64, typ };
+};
+var verifyKeyProofSignature = (decoded) => {
+  let keyBytes;
+  try {
+    const key = decodeMultikey(decoded.payload.publicKeyMultibase);
+    if (key.codec !== ED25519_PUB_MULTICODEC) {
+      throw new Error("publicKeyMultibase is not an Ed25519 public key");
+    }
+    keyBytes = key.keyBytes;
+  } catch (err) {
+    throw invalid(
+      "signature",
+      err instanceof Error ? err.message : "undecodable publicKeyMultibase"
+    );
+  }
+  let verified = false;
+  try {
+    verified = isValidEd25519Signature(
+      encoder.encode(`${decoded.headerB64}.${decoded.payloadB64}`),
+      base64urlDecode(decoded.signatureB64),
+      keyBytes
+    );
+  } catch {
+    verified = false;
+  }
+  if (!verified) throw invalid("signature", "signature does not verify against publicKeyMultibase");
+};
+var verifyKeyProof = (jws, options) => {
+  if (options.expectedTyp === "") {
+    throw new Error("invalid key proof verifier: expectedTyp must be a registered purpose value");
+  }
+  if (options.expectedAudience === "") {
+    throw new Error("invalid key proof verifier: expectedAudience must name this authority");
+  }
+  if (options.expectedDid === "") {
+    throw new Error("invalid key proof verifier: expectedDid must name the chain");
+  }
+  if (options.expectedPrevCID === "") {
+    throw new Error("invalid key proof verifier: expectedPrevCID must name the chain head");
+  }
+  if (!isCanonicalRoleSet(options.expectedRoleSet)) {
+    throw new Error(
+      "invalid key proof verifier: expectedRoleSet must be a canonical role set \u2014 build it with serializeRoleSet"
+    );
+  }
+  const maxSkew = options.maxSkewSeconds ?? DEFAULT_KEY_PROOF_SKEW_SECONDS;
+  if (!Number.isSafeInteger(maxSkew) || maxSkew < 0) {
+    throw new Error("invalid key proof verifier: maxSkewSeconds must be a non-negative integer");
+  }
+  const decoded = decodeKeyProof(jws, options.expectedTyp);
+  const payload = decoded.payload;
+  if (payload.audience !== options.expectedAudience) {
+    throw invalid("audience", "audience does not match this verifier authority");
+  }
+  if (payload.did !== options.expectedDid) {
+    throw invalid("did", "did does not match the chain this ceremony completes for");
+  }
+  if (payload.roleSet !== options.expectedRoleSet) {
+    throw invalid("roleSet", "roleSet does not match the roles this ceremony grants");
+  }
+  if (payload.prevCID !== options.expectedPrevCID) {
+    throw invalid("prevCID", "prevCID does not match the chain head this introduction builds on");
+  }
+  const now = Math.floor((options.now ? options.now() : Date.now()) / 1e3);
+  const issued = Math.floor(Date.parse(payload.timestamp) / 1e3);
+  if (Math.abs(now - issued) > maxSkew) {
+    throw invalid("freshness", "timestamp is outside the acceptance window");
+  }
+  verifyKeyProofSignature(decoded);
+  return { payload, typ: decoded.typ, now };
+};
+var unsafeKeyProofSubject = (jws) => {
+  const parts = jws.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const decoded = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(base64urlDecode(parts[1]))
+    );
+    if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+    const subject = decoded["publicKeyMultibase"];
+    return typeof subject === "string" ? subject : null;
+  } catch {
+    return null;
+  }
+};
+var verifyChainKeyProof = (jws, options) => {
+  if (options.expectedTyp === "") {
+    throw new Error("invalid key proof verifier: expectedTyp must be a registered purpose value");
+  }
+  const decoded = decodeKeyProof(jws, options.expectedTyp);
+  const payload = decoded.payload;
+  if (payload.publicKeyMultibase !== options.publicKeyMultibase) {
+    throw invalid("key", "publicKeyMultibase is not the key being introduced");
+  }
+  if (payload.did !== options.did) {
+    throw invalid("did", "did is not this chain");
+  }
+  if (payload.prevCID !== options.prevCID) {
+    throw invalid("prevCID", "prevCID is not the carrying operation previousOperationCID");
+  }
+  if (!roleSetCovers(payload.roleSet, options.role)) {
+    throw invalid("roleSet", `roleSet does not cover the ${options.role} role`);
+  }
+  verifyKeyProofSignature(decoded);
+  return payload;
+};
+
+// src/key-proof/pgp-word-list.ts
+var PGP_EVEN_WORDS = [
+  "aardvark",
+  "absurd",
+  "accrue",
+  "acme",
+  // 00
+  "adrift",
+  "adult",
+  "afflict",
+  "ahead",
+  // 04
+  "aimless",
+  "algol",
+  "allow",
+  "alone",
+  // 08
+  "ammo",
+  "ancient",
+  "apple",
+  "artist",
+  // 0c
+  "assume",
+  "athens",
+  "atlas",
+  "aztec",
+  // 10
+  "baboon",
+  "backfield",
+  "backward",
+  "banjo",
+  // 14
+  "beaming",
+  "bedlamp",
+  "beehive",
+  "beeswax",
+  // 18
+  "befriend",
+  "belfast",
+  "berserk",
+  "billiard",
+  // 1c
+  "bison",
+  "blackjack",
+  "blockade",
+  "blowtorch",
+  // 20
+  "bluebird",
+  "bombast",
+  "bookshelf",
+  "brackish",
+  // 24
+  "breadline",
+  "breakup",
+  "brickyard",
+  "briefcase",
+  // 28
+  "burbank",
+  "button",
+  "buzzard",
+  "cement",
+  // 2c
+  "chairlift",
+  "chatter",
+  "checkup",
+  "chisel",
+  // 30
+  "choking",
+  "chopper",
+  "christmas",
+  "clamshell",
+  // 34
+  "classic",
+  "classroom",
+  "cleanup",
+  "clockwork",
+  // 38
+  "cobra",
+  "commence",
+  "concert",
+  "cowbell",
+  // 3c
+  "crackdown",
+  "cranky",
+  "crowfoot",
+  "crucial",
+  // 40
+  "crumpled",
+  "crusade",
+  "cubic",
+  "dashboard",
+  // 44
+  "deadbolt",
+  "deckhand",
+  "dogsled",
+  "dragnet",
+  // 48
+  "drainage",
+  "dreadful",
+  "drifter",
+  "dropper",
+  // 4c
+  "drumbeat",
+  "drunken",
+  "dupont",
+  "dwelling",
+  // 50
+  "eating",
+  "edict",
+  "egghead",
+  "eightball",
+  // 54
+  "endorse",
+  "endow",
+  "enlist",
+  "erase",
+  // 58
+  "escape",
+  "exceed",
+  "eyeglass",
+  "eyetooth",
+  // 5c
+  "facial",
+  "fallout",
+  "flagpole",
+  "flatfoot",
+  // 60
+  "flytrap",
+  "fracture",
+  "framework",
+  "freedom",
+  // 64
+  "frighten",
+  "gazelle",
+  "geiger",
+  "glitter",
+  // 68
+  "glucose",
+  "goggles",
+  "goldfish",
+  "gremlin",
+  // 6c
+  "guidance",
+  "hamlet",
+  "highchair",
+  "hockey",
+  // 70
+  "indoors",
+  "indulge",
+  "inverse",
+  "involve",
+  // 74
+  "island",
+  "jawbone",
+  "keyboard",
+  "kickoff",
+  // 78
+  "kiwi",
+  "klaxon",
+  "locale",
+  "lockup",
+  // 7c
+  "merit",
+  "minnow",
+  "miser",
+  "mohawk",
+  // 80
+  "mural",
+  "music",
+  "necklace",
+  "neptune",
+  // 84
+  "newborn",
+  "nightbird",
+  "oakland",
+  "obtuse",
+  // 88
+  "offload",
+  "optic",
+  "orca",
+  "payday",
+  // 8c
+  "peachy",
+  "pheasant",
+  "physique",
+  "playhouse",
+  // 90
+  "pluto",
+  "preclude",
+  "prefer",
+  "preshrunk",
+  // 94
+  "printer",
+  "prowler",
+  "pupil",
+  "puppy",
+  // 98
+  "python",
+  "quadrant",
+  "quiver",
+  "quota",
+  // 9c
+  "ragtime",
+  "ratchet",
+  "rebirth",
+  "reform",
+  // a0
+  "regain",
+  "reindeer",
+  "rematch",
+  "repay",
+  // a4
+  "retouch",
+  "revenge",
+  "reward",
+  "rhythm",
+  // a8
+  "ribcage",
+  "ringbolt",
+  "robust",
+  "rocker",
+  // ac
+  "ruffled",
+  "sailboat",
+  "sawdust",
+  "scallion",
+  // b0
+  "scenic",
+  "scorecard",
+  "scotland",
+  "seabird",
+  // b4
+  "select",
+  "sentence",
+  "shadow",
+  "shamrock",
+  // b8
+  "showgirl",
+  "skullcap",
+  "skydive",
+  "slingshot",
+  // bc
+  "slowdown",
+  "snapline",
+  "snapshot",
+  "snowcap",
+  // c0
+  "snowslide",
+  "solo",
+  "southward",
+  "soybean",
+  // c4
+  "spaniel",
+  "spearhead",
+  "spellbind",
+  "spheroid",
+  // c8
+  "spigot",
+  "spindle",
+  "spyglass",
+  "stagehand",
+  // cc
+  "stagnate",
+  "stairway",
+  "standard",
+  "stapler",
+  // d0
+  "steamship",
+  "sterling",
+  "stockman",
+  "stopwatch",
+  // d4
+  "stormy",
+  "sugar",
+  "surmount",
+  "suspense",
+  // d8
+  "sweatband",
+  "swelter",
+  "tactics",
+  "talon",
+  // dc
+  "tapeworm",
+  "tempest",
+  "tiger",
+  "tissue",
+  // e0
+  "tonic",
+  "topmost",
+  "tracker",
+  "transit",
+  // e4
+  "trauma",
+  "treadmill",
+  "trojan",
+  "trouble",
+  // e8
+  "tumor",
+  "tunnel",
+  "tycoon",
+  "uncut",
+  // ec
+  "unearth",
+  "unwind",
+  "uproot",
+  "upset",
+  // f0
+  "upshot",
+  "vapor",
+  "village",
+  "virus",
+  // f4
+  "vulcan",
+  "waffle",
+  "wallet",
+  "watchword",
+  // f8
+  "wayside",
+  "willow",
+  "woodlark",
+  "zulu"
+  // fc
+];
+var PGP_ODD_WORDS = [
+  "adroitness",
+  "adviser",
+  "aftermath",
+  "aggregate",
+  // 00
+  "alkali",
+  "almighty",
+  "amulet",
+  "amusement",
+  // 04
+  "antenna",
+  "applicant",
+  "apollo",
+  "armistice",
+  // 08
+  "article",
+  "asteroid",
+  "atlantic",
+  "atmosphere",
+  // 0c
+  "autopsy",
+  "babylon",
+  "backwater",
+  "barbecue",
+  // 10
+  "belowground",
+  "bifocals",
+  "bodyguard",
+  "bookseller",
+  // 14
+  "borderline",
+  "bottomless",
+  "bradbury",
+  "bravado",
+  // 18
+  "brazilian",
+  "breakaway",
+  "burlington",
+  "businessman",
+  // 1c
+  "butterfat",
+  "camelot",
+  "candidate",
+  "cannonball",
+  // 20
+  "capricorn",
+  "caravan",
+  "caretaker",
+  "celebrate",
+  // 24
+  "cellulose",
+  "certify",
+  "chambermaid",
+  "cherokee",
+  // 28
+  "chicago",
+  "clergyman",
+  "coherence",
+  "combustion",
+  // 2c
+  "commando",
+  "company",
+  "component",
+  "concurrent",
+  // 30
+  "confidence",
+  "conformist",
+  "congregate",
+  "consensus",
+  // 34
+  "consulting",
+  "corporate",
+  "corrosion",
+  "councilman",
+  // 38
+  "crossover",
+  "crucifix",
+  "cumbersome",
+  "customer",
+  // 3c
+  "dakota",
+  "decadence",
+  "december",
+  "decimal",
+  // 40
+  "designing",
+  "detector",
+  "detergent",
+  "determine",
+  // 44
+  "dictator",
+  "dinosaur",
+  "direction",
+  "disable",
+  // 48
+  "disbelief",
+  "disruptive",
+  "distortion",
+  "document",
+  // 4c
+  "embezzle",
+  "enchanting",
+  "enrollment",
+  "enterprise",
+  // 50
+  "equation",
+  "equipment",
+  "escapade",
+  "eskimo",
+  // 54
+  "everyday",
+  "examine",
+  "existence",
+  "exodus",
+  // 58
+  "fascinate",
+  "filament",
+  "finicky",
+  "forever",
+  // 5c
+  "fortitude",
+  "frequency",
+  "gadgetry",
+  "galveston",
+  // 60
+  "getaway",
+  "glossary",
+  "gossamer",
+  "graduate",
+  // 64
+  "gravity",
+  "guitarist",
+  "hamburger",
+  "hamilton",
+  // 68
+  "handiwork",
+  "hazardous",
+  "headwaters",
+  "hemisphere",
+  // 6c
+  "hesitate",
+  "hideaway",
+  "holiness",
+  "hurricane",
+  // 70
+  "hydraulic",
+  "impartial",
+  "impetus",
+  "inception",
+  // 74
+  "indigo",
+  "inertia",
+  "infancy",
+  "inferno",
+  // 78
+  "informant",
+  "insincere",
+  "insurgent",
+  "integrate",
+  // 7c
+  "intention",
+  "inventive",
+  "istanbul",
+  "jamaica",
+  // 80
+  "jupiter",
+  "leprosy",
+  "letterhead",
+  "liberty",
+  // 84
+  "maritime",
+  "matchmaker",
+  "maverick",
+  "medusa",
+  // 88
+  "megaton",
+  "microscope",
+  "microwave",
+  "midsummer",
+  // 8c
+  "millionaire",
+  "miracle",
+  "misnomer",
+  "molasses",
+  // 90
+  "molecule",
+  "montana",
+  "monument",
+  "mosquito",
+  // 94
+  "narrative",
+  "nebula",
+  "newsletter",
+  "norwegian",
+  // 98
+  "october",
+  "ohio",
+  "onlooker",
+  "opulent",
+  // 9c
+  "orlando",
+  "outfielder",
+  "pacific",
+  "pandemic",
+  // a0
+  "pandora",
+  "paperweight",
+  "paragon",
+  "paragraph",
+  // a4
+  "paramount",
+  "passenger",
+  "pedigree",
+  "pegasus",
+  // a8
+  "penetrate",
+  "perceptive",
+  "performance",
+  "pharmacy",
+  // ac
+  "phonetic",
+  "photograph",
+  "pioneer",
+  "pocketful",
+  // b0
+  "politeness",
+  "positive",
+  "potato",
+  "processor",
+  // b4
+  "provincial",
+  "proximate",
+  "puberty",
+  "publisher",
+  // b8
+  "pyramid",
+  "quantity",
+  "racketeer",
+  "rebellion",
+  // bc
+  "recipe",
+  "recover",
+  "repellent",
+  "replica",
+  // c0
+  "reproduce",
+  "resistor",
+  "responsive",
+  "retraction",
+  // c4
+  "retrieval",
+  "retrospect",
+  "revenue",
+  "revival",
+  // c8
+  "revolver",
+  "sandalwood",
+  "sardonic",
+  "saturday",
+  // cc
+  "savagery",
+  "scavenger",
+  "sensation",
+  "sociable",
+  // d0
+  "souvenir",
+  "specialist",
+  "speculate",
+  "stethoscope",
+  // d4
+  "stupendous",
+  "supportive",
+  "surrender",
+  "suspicious",
+  // d8
+  "sympathy",
+  "tambourine",
+  "telephone",
+  "therapist",
+  // dc
+  "tobacco",
+  "tolerance",
+  "tomorrow",
+  "torpedo",
+  // e0
+  "tradition",
+  "travesty",
+  "trombonist",
+  "truncated",
+  // e4
+  "typewriter",
+  "ultimate",
+  "undaunted",
+  "underfoot",
+  // e8
+  "unicorn",
+  "unify",
+  "universe",
+  "unravel",
+  // ec
+  "upcoming",
+  "vacancy",
+  "vagabond",
+  "vertigo",
+  // f0
+  "virginia",
+  "visitor",
+  "vocalist",
+  "voyager",
+  // f4
+  "warranty",
+  "waterloo",
+  "whimsical",
+  "wichita",
+  // f8
+  "wilmington",
+  "wyoming",
+  "yesteryear",
+  "yucatan"
+  // fc
+];
+var pgpWords = (data) => Array.from(
+  data,
+  (byte, index) => index % 2 === 0 ? PGP_EVEN_WORDS[byte] : PGP_ODD_WORDS[byte]
+).join(" ");
+
+// src/key-proof/word-fingerprint.ts
+var FINGERPRINT_BYTES = 6;
+var keyWordFingerprint = (publicKeyMultibase) => pgpWords(sha256(new TextEncoder().encode(publicKeyMultibase)).slice(0, FINGERPRINT_BYTES));
+
+export {
+  KEY_ROLES,
+  serializeRoleSet,
+  parseRoleSet,
+  isCanonicalRoleSet,
+  roleSetCovers,
+  KEY_ADD_JWS_TYP,
+  MAX_KEY_PROOF_SIZE,
+  DEFAULT_KEY_PROOF_SKEW_SECONDS,
+  KeyProofVerifyError,
+  keyProofSigningInput,
+  signKeyProof,
+  verifyKeyProof,
+  unsafeKeyProofSubject,
+  verifyChainKeyProof,
+  keyWordFingerprint
+};