@calimero-network/mero-js 19.5.0 → 19.7.0

package/dist/index.cjs

@@ -39,6 +39,8 @@ __export(index_exports, {
   WebHttpClient: () => WebHttpClient,
   WsClient: () => WsClient,
   accountForRoot: () => accountForRoot,
+  accountRootFromPhrase: () => accountRootFromPhrase,
+  accountRootFromSecret: () => accountRootFromSecret,
   buildAuthLoginUrl: () => buildAuthLoginUrl,
   combineSignals: () => combineSignals,
   compareSemver: () => compareSemver,
@@ -63,6 +65,7 @@ __export(index_exports, {
   deviceCertPayload: () => deviceCertPayload,
   discoverLocalNodes: () => discoverLocalNodes,
   encodeSignedInvitation: () => encodeSignedInvitation,
+  generateAccountRoot: () => generateAccountRoot,
   generateSessionKey: () => generateSessionKey,
   hasCap: () => hasCap,
   intentHash: () => intentHash,
@@ -73,6 +76,7 @@ __export(index_exports, {
   nodeEndpoint: () => nodeEndpoint,
   parseAuthCallback: () => parseAuthCallback,
   probeNodeHealth: () => probeNodeHealth,
+  signAccountLink: () => signAccountLink,
   signDeviceCert: () => signDeviceCert,
   signLoginStatement: () => signLoginStatement,
   signMemberJoinOp: () => signMemberJoinOp,
@@ -782,6 +786,41 @@ function createAuthApiClientFromHttpClient(httpClient, _config) {
   return new AuthApiClient(httpClient);
 }
 
+// src/capabilities.ts
+var CAPABILITIES = {
+  CAN_CREATE_CONTEXT: 1 << 0,
+  CAN_INVITE_MEMBERS: 1 << 1,
+  CAN_JOIN_OPEN_SUBGROUPS: 1 << 2,
+  MANAGE_MEMBERS: 1 << 3,
+  MANAGE_APPLICATION: 1 << 4,
+  CAN_CREATE_SUBGROUP: 1 << 5,
+  CAN_DELETE_SUBGROUP: 1 << 6,
+  CAN_MANAGE_VISIBILITY: 1 << 7,
+  CAN_MANAGE_METADATA: 1 << 8,
+  /**
+   * Publish writes attributed to ANOTHER member, under a warrant that member
+   * signed — the grant delegated execution runs on.
+   *
+   * Implied by nothing: not by membership, not by admin, and not propagated by
+   * the subgroup-admit cascade. So every group is authorship-closed until an
+   * admin sets this bit, and a relay without it is refused at
+   * `performIntent` before anything executes. That is why it is worth naming
+   * here rather than leaving callers to write `1 << 9`: a client granting it
+   * has to be able to say what it is granting.
+   */
+  CAN_AUTHOR_ON_BEHALF: 1 << 9
+};
+function hasCap(mask, cap) {
+  const capU32 = cap >>> 0;
+  return (mask & capU32) >>> 0 === capU32;
+}
+function withCap(mask, cap) {
+  return (mask | cap) >>> 0;
+}
+function withoutCap(mask, cap) {
+  return (mask & ~cap) >>> 0;
+}
+
 // src/admin-api/admin-client.ts
 function unwrap(response) {
   return response?.data;
@@ -1540,6 +1579,85 @@ var AdminApiClient = class {
   async setDefaultCapabilities(groupId, request) {
     await this.httpClient.put(`/admin-api/groups/${groupId}/settings/default-capabilities`, request);
   }
+  /**
+   * Make every member admitted to `groupId` from now on able to relay a
+   * delegated write, without a per-node governance op each time.
+   *
+   * `CAN_AUTHOR_ON_BEHALF` is implied by nothing — not membership, not admin —
+   * so every group is authorship-closed and each fleet relay otherwise needs an
+   * admin to grant it individually, at the moment the relay is assigned and the
+   * admin is not watching. Setting it in the group's DEFAULT mask is core's own
+   * answer to that: `add_member` seeds a non-admin's capability row from the
+   * default, so an attested node admitted afterwards lands open.
+   *
+   * Call it on the NAMESPACE (the root group). A grant resolves through the
+   * membership anchor, so one at the root reaches every Open subgroup beneath
+   * it, which is where contexts actually live; a `Restricted` subgroup is a
+   * membership boundary and needs its own call.
+   *
+   * ### Two things this does not do
+   *
+   * **It is not retroactive.** The default is copied into a member's row when
+   * that member is admitted, so nodes already admitted keep the row they got.
+   * Use {@link grantAuthorship} for those — or call this at namespace creation,
+   * which is the only point that needs no backfill at all.
+   *
+   * **It does not reach admins.** Core seeds the default only for non-admin
+   * roles, and `CAN_AUTHOR_ON_BEHALF` is deliberately not implied by admin. An
+   * admin's own node therefore stays closed and needs {@link grantAuthorship}.
+   *
+   * ### What it widens
+   *
+   * Every future non-admin member of the group, not only attested TEE nodes, so
+   * any of them may be named as a warrant's `executor`. The bound worth knowing
+   * before deciding: an executor cannot FORGE. A delegated write is authorized
+   * by the author's own warrant — signed by their device key, committed to one
+   * context, method and exact arguments, with its nonce checked unspent — so a
+   * holder can only spend a warrant it was deliberately handed. What it does
+   * gain is the arguments in cleartext and the choice of when, or whether, to
+   * publish.
+   *
+   * Read-modify-write rather than a blind set: core seeds a new group's default
+   * with `CAN_JOIN_OPEN_SUBGROUPS`, and overwriting that would quietly stop
+   * every later member inheriting into Open subgroups.
+   *
+   * Returns the resulting mask and whether an op was published — it is a no-op
+   * when the bit is already set, so it is safe to call on every startup.
+   */
+  async openToDelegatedExecution(groupId) {
+    const current = await this.getDefaultCapabilities(groupId);
+    if (hasCap(current, CAPABILITIES.CAN_AUTHOR_ON_BEHALF)) {
+      return { changed: false, defaultCapabilities: current };
+    }
+    const next = withCap(current, CAPABILITIES.CAN_AUTHOR_ON_BEHALF);
+    await this.setDefaultCapabilities(groupId, { defaultCapabilities: next });
+    return { changed: true, defaultCapabilities: next };
+  }
+  /**
+   * Grant `account` the authorship bit on `groupId`, leaving its other
+   * capabilities alone.
+   *
+   * The per-member counterpart to {@link openToDelegatedExecution}, and what
+   * closes the gap that method cannot: a relay admitted BEFORE the default was
+   * set, and an admin's own node, which never receives the default at all.
+   *
+   * `account` is the member's ACCOUNT id (64 hex) as `listGroupMembers` returns
+   * it — for a fleet relay, the `account` the cloud reports for that node. Not
+   * the signing key that added them; both are 64 hex, so nothing but the source
+   * tells them apart.
+   *
+   * Read-modify-write, so it adds the bit rather than replacing the member's
+   * mask. A no-op when the member already holds it.
+   */
+  async grantAuthorship(groupId, account) {
+    const { capabilities } = await this.getMemberCapabilities(groupId, account);
+    if (hasCap(capabilities, CAPABILITIES.CAN_AUTHOR_ON_BEHALF)) {
+      return { changed: false, capabilities };
+    }
+    const next = withCap(capabilities, CAPABILITIES.CAN_AUTHOR_ON_BEHALF);
+    await this.setMemberCapabilities(groupId, account, { capabilities: next });
+    return { changed: true, capabilities: next };
+  }
   async setSubgroupVisibility(groupId, request) {
     await this.httpClient.put(`/admin-api/groups/${groupId}/settings/subgroup-visibility`, request);
   }
@@ -2400,6 +2518,2326 @@ var EphemeralClient = class {
   }
 };
 
+// src/crypto/internal.ts
+var PKCS8_ED25519_PREFIX = new Uint8Array([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  4,
+  34,
+  4,
+  32
+]);
+function u32le(value) {
+  const out = new Uint8Array(4);
+  new DataView(out.buffer).setUint32(0, value, true);
+  return out;
+}
+function hex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(value, label, expectedBytes) {
+  const clean = value.trim();
+  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length !== expectedBytes * 2) {
+    throw new Error(
+      `${label} must be ${expectedBytes * 2} hex characters, got ${clean.length}`
+    );
+  }
+  const bytes = new Uint8Array(expectedBytes);
+  for (let i = 0; i < expectedBytes; i += 1) {
+    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function u64le(value) {
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigUint64(0, BigInt(value), true);
+  return out;
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((total, p) => total + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+async function domainHash(domain, parts) {
+  const chunks = [u64le(domain.length), domain];
+  for (const part of parts) {
+    chunks.push(u64le(part.length), part);
+  }
+  return new Uint8Array(
+    await crypto.subtle.digest("SHA-256", concat(...chunks))
+  );
+}
+async function importSigningKey(secretHex) {
+  const seed = fromHex(secretHex, "deviceSecret", 32);
+  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
+  try {
+    return await crypto.subtle.importKey(
+      "pkcs8",
+      pkcs8,
+      { name: "Ed25519" },
+      false,
+      ["sign"]
+    );
+  } catch (cause) {
+    const detail = cause instanceof Error ? `: ${cause.message}` : "";
+    throw new Error(
+      "this runtime has no WebCrypto Ed25519, so a warrant cannot be signed here. Node 18.4+, Safari 17+, Firefox 129+ and Chrome 137+ have it; otherwise mint the warrant with `merod account warrant`" + detail
+    );
+  }
+}
+async function derivePublicKey(secretHex) {
+  const seed = fromHex(secretHex, "deviceSecret", 32);
+  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    pkcs8,
+    { name: "Ed25519" },
+    true,
+    ["sign"]
+  );
+  const jwk = await crypto.subtle.exportKey("jwk", key);
+  const raw = jwk.x;
+  return Uint8Array.from(
+    atob(raw.replace(/-/g, "+").replace(/_/g, "/")),
+    (c) => c.charCodeAt(0)
+  );
+}
+
+// src/device-cert/device-cert.ts
+var CERT_DOMAIN = new TextEncoder().encode("calimero.device.cert.v1");
+var ACCOUNT_ID_DOMAIN = new TextEncoder().encode("calimero.account.genesis.v1");
+var DEVICE_ID_DOMAIN = new TextEncoder().encode("calimero.device.id.v1");
+var ACCOUNT_GENESIS_VERSION = 2;
+async function mintDeviceId(account, nonce) {
+  if (nonce.length !== 16) {
+    throw new Error(`nonce must be 16 bytes, got ${nonce.length}`);
+  }
+  const accountBytes = fromHex(account, "account", 32);
+  return hex(await domainHash(DEVICE_ID_DOMAIN, [accountBytes, nonce]));
+}
+async function deviceCertPayload(input) {
+  return domainHash(CERT_DOMAIN, [
+    fromHex(input.account, "account", 32),
+    fromHex(input.device, "device", 32),
+    fromHex(input.signPublicKey, "signPublicKey", 32),
+    fromHex(input.kemPublicKey, "kemPublicKey", 32),
+    u32le(input.keyEpoch),
+    u32le(input.deviceEpoch)
+  ]);
+}
+function accountProofBytes(input) {
+  return concat(
+    new Uint8Array([ACCOUNT_GENESIS_VERSION]),
+    input.rootPublicKey,
+    u32le(0),
+    fromHex(input.account, "account", 32),
+    fromHex(input.device, "device", 32),
+    fromHex(input.signPublicKey, "signPublicKey", 32),
+    fromHex(input.kemPublicKey, "kemPublicKey", 32),
+    u32le(input.keyEpoch),
+    u32le(input.deviceEpoch),
+    input.signature
+  );
+}
+async function signDeviceCert(input) {
+  const rootPublicKey = await derivePublicKey(input.rootSecret);
+  const account = hex(
+    await domainHash(ACCOUNT_ID_DOMAIN, [
+      concat(new Uint8Array([ACCOUNT_GENESIS_VERSION]), rootPublicKey)
+    ])
+  );
+  const keyEpoch = 0;
+  const payload = await deviceCertPayload({
+    account,
+    device: input.device,
+    signPublicKey: input.signPublicKey,
+    kemPublicKey: input.kemPublicKey,
+    keyEpoch,
+    deviceEpoch: input.deviceEpoch
+  });
+  const key = await importSigningKey(input.rootSecret);
+  const signature = new Uint8Array(
+    await crypto.subtle.sign("Ed25519", key, payload)
+  );
+  const credential = accountProofBytes({
+    rootPublicKey,
+    account,
+    device: input.device,
+    signPublicKey: input.signPublicKey,
+    kemPublicKey: input.kemPublicKey,
+    keyEpoch,
+    deviceEpoch: input.deviceEpoch,
+    signature
+  });
+  return hex(credential);
+}
+async function accountForRoot(rootSecret) {
+  const rootPublicKey = await derivePublicKey(rootSecret);
+  return hex(
+    await domainHash(ACCOUNT_ID_DOMAIN, [
+      concat(new Uint8Array([ACCOUNT_GENESIS_VERSION]), rootPublicKey)
+    ])
+  );
+}
+
+// src/account/wordlist.ts
+var ENGLISH_WORDLIST = [
+  "abandon",
+  "ability",
+  "able",
+  "about",
+  "above",
+  "absent",
+  "absorb",
+  "abstract",
+  "absurd",
+  "abuse",
+  "access",
+  "accident",
+  "account",
+  "accuse",
+  "achieve",
+  "acid",
+  "acoustic",
+  "acquire",
+  "across",
+  "act",
+  "action",
+  "actor",
+  "actress",
+  "actual",
+  "adapt",
+  "add",
+  "addict",
+  "address",
+  "adjust",
+  "admit",
+  "adult",
+  "advance",
+  "advice",
+  "aerobic",
+  "affair",
+  "afford",
+  "afraid",
+  "again",
+  "age",
+  "agent",
+  "agree",
+  "ahead",
+  "aim",
+  "air",
+  "airport",
+  "aisle",
+  "alarm",
+  "album",
+  "alcohol",
+  "alert",
+  "alien",
+  "all",
+  "alley",
+  "allow",
+  "almost",
+  "alone",
+  "alpha",
+  "already",
+  "also",
+  "alter",
+  "always",
+  "amateur",
+  "amazing",
+  "among",
+  "amount",
+  "amused",
+  "analyst",
+  "anchor",
+  "ancient",
+  "anger",
+  "angle",
+  "angry",
+  "animal",
+  "ankle",
+  "announce",
+  "annual",
+  "another",
+  "answer",
+  "antenna",
+  "antique",
+  "anxiety",
+  "any",
+  "apart",
+  "apology",
+  "appear",
+  "apple",
+  "approve",
+  "april",
+  "arch",
+  "arctic",
+  "area",
+  "arena",
+  "argue",
+  "arm",
+  "armed",
+  "armor",
+  "army",
+  "around",
+  "arrange",
+  "arrest",
+  "arrive",
+  "arrow",
+  "art",
+  "artefact",
+  "artist",
+  "artwork",
+  "ask",
+  "aspect",
+  "assault",
+  "asset",
+  "assist",
+  "assume",
+  "asthma",
+  "athlete",
+  "atom",
+  "attack",
+  "attend",
+  "attitude",
+  "attract",
+  "auction",
+  "audit",
+  "august",
+  "aunt",
+  "author",
+  "auto",
+  "autumn",
+  "average",
+  "avocado",
+  "avoid",
+  "awake",
+  "aware",
+  "away",
+  "awesome",
+  "awful",
+  "awkward",
+  "axis",
+  "baby",
+  "bachelor",
+  "bacon",
+  "badge",
+  "bag",
+  "balance",
+  "balcony",
+  "ball",
+  "bamboo",
+  "banana",
+  "banner",
+  "bar",
+  "barely",
+  "bargain",
+  "barrel",
+  "base",
+  "basic",
+  "basket",
+  "battle",
+  "beach",
+  "bean",
+  "beauty",
+  "because",
+  "become",
+  "beef",
+  "before",
+  "begin",
+  "behave",
+  "behind",
+  "believe",
+  "below",
+  "belt",
+  "bench",
+  "benefit",
+  "best",
+  "betray",
+  "better",
+  "between",
+  "beyond",
+  "bicycle",
+  "bid",
+  "bike",
+  "bind",
+  "biology",
+  "bird",
+  "birth",
+  "bitter",
+  "black",
+  "blade",
+  "blame",
+  "blanket",
+  "blast",
+  "bleak",
+  "bless",
+  "blind",
+  "blood",
+  "blossom",
+  "blouse",
+  "blue",
+  "blur",
+  "blush",
+  "board",
+  "boat",
+  "body",
+  "boil",
+  "bomb",
+  "bone",
+  "bonus",
+  "book",
+  "boost",
+  "border",
+  "boring",
+  "borrow",
+  "boss",
+  "bottom",
+  "bounce",
+  "box",
+  "boy",
+  "bracket",
+  "brain",
+  "brand",
+  "brass",
+  "brave",
+  "bread",
+  "breeze",
+  "brick",
+  "bridge",
+  "brief",
+  "bright",
+  "bring",
+  "brisk",
+  "broccoli",
+  "broken",
+  "bronze",
+  "broom",
+  "brother",
+  "brown",
+  "brush",
+  "bubble",
+  "buddy",
+  "budget",
+  "buffalo",
+  "build",
+  "bulb",
+  "bulk",
+  "bullet",
+  "bundle",
+  "bunker",
+  "burden",
+  "burger",
+  "burst",
+  "bus",
+  "business",
+  "busy",
+  "butter",
+  "buyer",
+  "buzz",
+  "cabbage",
+  "cabin",
+  "cable",
+  "cactus",
+  "cage",
+  "cake",
+  "call",
+  "calm",
+  "camera",
+  "camp",
+  "can",
+  "canal",
+  "cancel",
+  "candy",
+  "cannon",
+  "canoe",
+  "canvas",
+  "canyon",
+  "capable",
+  "capital",
+  "captain",
+  "car",
+  "carbon",
+  "card",
+  "cargo",
+  "carpet",
+  "carry",
+  "cart",
+  "case",
+  "cash",
+  "casino",
+  "castle",
+  "casual",
+  "cat",
+  "catalog",
+  "catch",
+  "category",
+  "cattle",
+  "caught",
+  "cause",
+  "caution",
+  "cave",
+  "ceiling",
+  "celery",
+  "cement",
+  "census",
+  "century",
+  "cereal",
+  "certain",
+  "chair",
+  "chalk",
+  "champion",
+  "change",
+  "chaos",
+  "chapter",
+  "charge",
+  "chase",
+  "chat",
+  "cheap",
+  "check",
+  "cheese",
+  "chef",
+  "cherry",
+  "chest",
+  "chicken",
+  "chief",
+  "child",
+  "chimney",
+  "choice",
+  "choose",
+  "chronic",
+  "chuckle",
+  "chunk",
+  "churn",
+  "cigar",
+  "cinnamon",
+  "circle",
+  "citizen",
+  "city",
+  "civil",
+  "claim",
+  "clap",
+  "clarify",
+  "claw",
+  "clay",
+  "clean",
+  "clerk",
+  "clever",
+  "click",
+  "client",
+  "cliff",
+  "climb",
+  "clinic",
+  "clip",
+  "clock",
+  "clog",
+  "close",
+  "cloth",
+  "cloud",
+  "clown",
+  "club",
+  "clump",
+  "cluster",
+  "clutch",
+  "coach",
+  "coast",
+  "coconut",
+  "code",
+  "coffee",
+  "coil",
+  "coin",
+  "collect",
+  "color",
+  "column",
+  "combine",
+  "come",
+  "comfort",
+  "comic",
+  "common",
+  "company",
+  "concert",
+  "conduct",
+  "confirm",
+  "congress",
+  "connect",
+  "consider",
+  "control",
+  "convince",
+  "cook",
+  "cool",
+  "copper",
+  "copy",
+  "coral",
+  "core",
+  "corn",
+  "correct",
+  "cost",
+  "cotton",
+  "couch",
+  "country",
+  "couple",
+  "course",
+  "cousin",
+  "cover",
+  "coyote",
+  "crack",
+  "cradle",
+  "craft",
+  "cram",
+  "crane",
+  "crash",
+  "crater",
+  "crawl",
+  "crazy",
+  "cream",
+  "credit",
+  "creek",
+  "crew",
+  "cricket",
+  "crime",
+  "crisp",
+  "critic",
+  "crop",
+  "cross",
+  "crouch",
+  "crowd",
+  "crucial",
+  "cruel",
+  "cruise",
+  "crumble",
+  "crunch",
+  "crush",
+  "cry",
+  "crystal",
+  "cube",
+  "culture",
+  "cup",
+  "cupboard",
+  "curious",
+  "current",
+  "curtain",
+  "curve",
+  "cushion",
+  "custom",
+  "cute",
+  "cycle",
+  "dad",
+  "damage",
+  "damp",
+  "dance",
+  "danger",
+  "daring",
+  "dash",
+  "daughter",
+  "dawn",
+  "day",
+  "deal",
+  "debate",
+  "debris",
+  "decade",
+  "december",
+  "decide",
+  "decline",
+  "decorate",
+  "decrease",
+  "deer",
+  "defense",
+  "define",
+  "defy",
+  "degree",
+  "delay",
+  "deliver",
+  "demand",
+  "demise",
+  "denial",
+  "dentist",
+  "deny",
+  "depart",
+  "depend",
+  "deposit",
+  "depth",
+  "deputy",
+  "derive",
+  "describe",
+  "desert",
+  "design",
+  "desk",
+  "despair",
+  "destroy",
+  "detail",
+  "detect",
+  "develop",
+  "device",
+  "devote",
+  "diagram",
+  "dial",
+  "diamond",
+  "diary",
+  "dice",
+  "diesel",
+  "diet",
+  "differ",
+  "digital",
+  "dignity",
+  "dilemma",
+  "dinner",
+  "dinosaur",
+  "direct",
+  "dirt",
+  "disagree",
+  "discover",
+  "disease",
+  "dish",
+  "dismiss",
+  "disorder",
+  "display",
+  "distance",
+  "divert",
+  "divide",
+  "divorce",
+  "dizzy",
+  "doctor",
+  "document",
+  "dog",
+  "doll",
+  "dolphin",
+  "domain",
+  "donate",
+  "donkey",
+  "donor",
+  "door",
+  "dose",
+  "double",
+  "dove",
+  "draft",
+  "dragon",
+  "drama",
+  "drastic",
+  "draw",
+  "dream",
+  "dress",
+  "drift",
+  "drill",
+  "drink",
+  "drip",
+  "drive",
+  "drop",
+  "drum",
+  "dry",
+  "duck",
+  "dumb",
+  "dune",
+  "during",
+  "dust",
+  "dutch",
+  "duty",
+  "dwarf",
+  "dynamic",
+  "eager",
+  "eagle",
+  "early",
+  "earn",
+  "earth",
+  "easily",
+  "east",
+  "easy",
+  "echo",
+  "ecology",
+  "economy",
+  "edge",
+  "edit",
+  "educate",
+  "effort",
+  "egg",
+  "eight",
+  "either",
+  "elbow",
+  "elder",
+  "electric",
+  "elegant",
+  "element",
+  "elephant",
+  "elevator",
+  "elite",
+  "else",
+  "embark",
+  "embody",
+  "embrace",
+  "emerge",
+  "emotion",
+  "employ",
+  "empower",
+  "empty",
+  "enable",
+  "enact",
+  "end",
+  "endless",
+  "endorse",
+  "enemy",
+  "energy",
+  "enforce",
+  "engage",
+  "engine",
+  "enhance",
+  "enjoy",
+  "enlist",
+  "enough",
+  "enrich",
+  "enroll",
+  "ensure",
+  "enter",
+  "entire",
+  "entry",
+  "envelope",
+  "episode",
+  "equal",
+  "equip",
+  "era",
+  "erase",
+  "erode",
+  "erosion",
+  "error",
+  "erupt",
+  "escape",
+  "essay",
+  "essence",
+  "estate",
+  "eternal",
+  "ethics",
+  "evidence",
+  "evil",
+  "evoke",
+  "evolve",
+  "exact",
+  "example",
+  "excess",
+  "exchange",
+  "excite",
+  "exclude",
+  "excuse",
+  "execute",
+  "exercise",
+  "exhaust",
+  "exhibit",
+  "exile",
+  "exist",
+  "exit",
+  "exotic",
+  "expand",
+  "expect",
+  "expire",
+  "explain",
+  "expose",
+  "express",
+  "extend",
+  "extra",
+  "eye",
+  "eyebrow",
+  "fabric",
+  "face",
+  "faculty",
+  "fade",
+  "faint",
+  "faith",
+  "fall",
+  "false",
+  "fame",
+  "family",
+  "famous",
+  "fan",
+  "fancy",
+  "fantasy",
+  "farm",
+  "fashion",
+  "fat",
+  "fatal",
+  "father",
+  "fatigue",
+  "fault",
+  "favorite",
+  "feature",
+  "february",
+  "federal",
+  "fee",
+  "feed",
+  "feel",
+  "female",
+  "fence",
+  "festival",
+  "fetch",
+  "fever",
+  "few",
+  "fiber",
+  "fiction",
+  "field",
+  "figure",
+  "file",
+  "film",
+  "filter",
+  "final",
+  "find",
+  "fine",
+  "finger",
+  "finish",
+  "fire",
+  "firm",
+  "first",
+  "fiscal",
+  "fish",
+  "fit",
+  "fitness",
+  "fix",
+  "flag",
+  "flame",
+  "flash",
+  "flat",
+  "flavor",
+  "flee",
+  "flight",
+  "flip",
+  "float",
+  "flock",
+  "floor",
+  "flower",
+  "fluid",
+  "flush",
+  "fly",
+  "foam",
+  "focus",
+  "fog",
+  "foil",
+  "fold",
+  "follow",
+  "food",
+  "foot",
+  "force",
+  "forest",
+  "forget",
+  "fork",
+  "fortune",
+  "forum",
+  "forward",
+  "fossil",
+  "foster",
+  "found",
+  "fox",
+  "fragile",
+  "frame",
+  "frequent",
+  "fresh",
+  "friend",
+  "fringe",
+  "frog",
+  "front",
+  "frost",
+  "frown",
+  "frozen",
+  "fruit",
+  "fuel",
+  "fun",
+  "funny",
+  "furnace",
+  "fury",
+  "future",
+  "gadget",
+  "gain",
+  "galaxy",
+  "gallery",
+  "game",
+  "gap",
+  "garage",
+  "garbage",
+  "garden",
+  "garlic",
+  "garment",
+  "gas",
+  "gasp",
+  "gate",
+  "gather",
+  "gauge",
+  "gaze",
+  "general",
+  "genius",
+  "genre",
+  "gentle",
+  "genuine",
+  "gesture",
+  "ghost",
+  "giant",
+  "gift",
+  "giggle",
+  "ginger",
+  "giraffe",
+  "girl",
+  "give",
+  "glad",
+  "glance",
+  "glare",
+  "glass",
+  "glide",
+  "glimpse",
+  "globe",
+  "gloom",
+  "glory",
+  "glove",
+  "glow",
+  "glue",
+  "goat",
+  "goddess",
+  "gold",
+  "good",
+  "goose",
+  "gorilla",
+  "gospel",
+  "gossip",
+  "govern",
+  "gown",
+  "grab",
+  "grace",
+  "grain",
+  "grant",
+  "grape",
+  "grass",
+  "gravity",
+  "great",
+  "green",
+  "grid",
+  "grief",
+  "grit",
+  "grocery",
+  "group",
+  "grow",
+  "grunt",
+  "guard",
+  "guess",
+  "guide",
+  "guilt",
+  "guitar",
+  "gun",
+  "gym",
+  "habit",
+  "hair",
+  "half",
+  "hammer",
+  "hamster",
+  "hand",
+  "happy",
+  "harbor",
+  "hard",
+  "harsh",
+  "harvest",
+  "hat",
+  "have",
+  "hawk",
+  "hazard",
+  "head",
+  "health",
+  "heart",
+  "heavy",
+  "hedgehog",
+  "height",
+  "hello",
+  "helmet",
+  "help",
+  "hen",
+  "hero",
+  "hidden",
+  "high",
+  "hill",
+  "hint",
+  "hip",
+  "hire",
+  "history",
+  "hobby",
+  "hockey",
+  "hold",
+  "hole",
+  "holiday",
+  "hollow",
+  "home",
+  "honey",
+  "hood",
+  "hope",
+  "horn",
+  "horror",
+  "horse",
+  "hospital",
+  "host",
+  "hotel",
+  "hour",
+  "hover",
+  "hub",
+  "huge",
+  "human",
+  "humble",
+  "humor",
+  "hundred",
+  "hungry",
+  "hunt",
+  "hurdle",
+  "hurry",
+  "hurt",
+  "husband",
+  "hybrid",
+  "ice",
+  "icon",
+  "idea",
+  "identify",
+  "idle",
+  "ignore",
+  "ill",
+  "illegal",
+  "illness",
+  "image",
+  "imitate",
+  "immense",
+  "immune",
+  "impact",
+  "impose",
+  "improve",
+  "impulse",
+  "inch",
+  "include",
+  "income",
+  "increase",
+  "index",
+  "indicate",
+  "indoor",
+  "industry",
+  "infant",
+  "inflict",
+  "inform",
+  "inhale",
+  "inherit",
+  "initial",
+  "inject",
+  "injury",
+  "inmate",
+  "inner",
+  "innocent",
+  "input",
+  "inquiry",
+  "insane",
+  "insect",
+  "inside",
+  "inspire",
+  "install",
+  "intact",
+  "interest",
+  "into",
+  "invest",
+  "invite",
+  "involve",
+  "iron",
+  "island",
+  "isolate",
+  "issue",
+  "item",
+  "ivory",
+  "jacket",
+  "jaguar",
+  "jar",
+  "jazz",
+  "jealous",
+  "jeans",
+  "jelly",
+  "jewel",
+  "job",
+  "join",
+  "joke",
+  "journey",
+  "joy",
+  "judge",
+  "juice",
+  "jump",
+  "jungle",
+  "junior",
+  "junk",
+  "just",
+  "kangaroo",
+  "keen",
+  "keep",
+  "ketchup",
+  "key",
+  "kick",
+  "kid",
+  "kidney",
+  "kind",
+  "kingdom",
+  "kiss",
+  "kit",
+  "kitchen",
+  "kite",
+  "kitten",
+  "kiwi",
+  "knee",
+  "knife",
+  "knock",
+  "know",
+  "lab",
+  "label",
+  "labor",
+  "ladder",
+  "lady",
+  "lake",
+  "lamp",
+  "language",
+  "laptop",
+  "large",
+  "later",
+  "latin",
+  "laugh",
+  "laundry",
+  "lava",
+  "law",
+  "lawn",
+  "lawsuit",
+  "layer",
+  "lazy",
+  "leader",
+  "leaf",
+  "learn",
+  "leave",
+  "lecture",
+  "left",
+  "leg",
+  "legal",
+  "legend",
+  "leisure",
+  "lemon",
+  "lend",
+  "length",
+  "lens",
+  "leopard",
+  "lesson",
+  "letter",
+  "level",
+  "liar",
+  "liberty",
+  "library",
+  "license",
+  "life",
+  "lift",
+  "light",
+  "like",
+  "limb",
+  "limit",
+  "link",
+  "lion",
+  "liquid",
+  "list",
+  "little",
+  "live",
+  "lizard",
+  "load",
+  "loan",
+  "lobster",
+  "local",
+  "lock",
+  "logic",
+  "lonely",
+  "long",
+  "loop",
+  "lottery",
+  "loud",
+  "lounge",
+  "love",
+  "loyal",
+  "lucky",
+  "luggage",
+  "lumber",
+  "lunar",
+  "lunch",
+  "luxury",
+  "lyrics",
+  "machine",
+  "mad",
+  "magic",
+  "magnet",
+  "maid",
+  "mail",
+  "main",
+  "major",
+  "make",
+  "mammal",
+  "man",
+  "manage",
+  "mandate",
+  "mango",
+  "mansion",
+  "manual",
+  "maple",
+  "marble",
+  "march",
+  "margin",
+  "marine",
+  "market",
+  "marriage",
+  "mask",
+  "mass",
+  "master",
+  "match",
+  "material",
+  "math",
+  "matrix",
+  "matter",
+  "maximum",
+  "maze",
+  "meadow",
+  "mean",
+  "measure",
+  "meat",
+  "mechanic",
+  "medal",
+  "media",
+  "melody",
+  "melt",
+  "member",
+  "memory",
+  "mention",
+  "menu",
+  "mercy",
+  "merge",
+  "merit",
+  "merry",
+  "mesh",
+  "message",
+  "metal",
+  "method",
+  "middle",
+  "midnight",
+  "milk",
+  "million",
+  "mimic",
+  "mind",
+  "minimum",
+  "minor",
+  "minute",
+  "miracle",
+  "mirror",
+  "misery",
+  "miss",
+  "mistake",
+  "mix",
+  "mixed",
+  "mixture",
+  "mobile",
+  "model",
+  "modify",
+  "mom",
+  "moment",
+  "monitor",
+  "monkey",
+  "monster",
+  "month",
+  "moon",
+  "moral",
+  "more",
+  "morning",
+  "mosquito",
+  "mother",
+  "motion",
+  "motor",
+  "mountain",
+  "mouse",
+  "move",
+  "movie",
+  "much",
+  "muffin",
+  "mule",
+  "multiply",
+  "muscle",
+  "museum",
+  "mushroom",
+  "music",
+  "must",
+  "mutual",
+  "myself",
+  "mystery",
+  "myth",
+  "naive",
+  "name",
+  "napkin",
+  "narrow",
+  "nasty",
+  "nation",
+  "nature",
+  "near",
+  "neck",
+  "need",
+  "negative",
+  "neglect",
+  "neither",
+  "nephew",
+  "nerve",
+  "nest",
+  "net",
+  "network",
+  "neutral",
+  "never",
+  "news",
+  "next",
+  "nice",
+  "night",
+  "noble",
+  "noise",
+  "nominee",
+  "noodle",
+  "normal",
+  "north",
+  "nose",
+  "notable",
+  "note",
+  "nothing",
+  "notice",
+  "novel",
+  "now",
+  "nuclear",
+  "number",
+  "nurse",
+  "nut",
+  "oak",
+  "obey",
+  "object",
+  "oblige",
+  "obscure",
+  "observe",
+  "obtain",
+  "obvious",
+  "occur",
+  "ocean",
+  "october",
+  "odor",
+  "off",
+  "offer",
+  "office",
+  "often",
+  "oil",
+  "okay",
+  "old",
+  "olive",
+  "olympic",
+  "omit",
+  "once",
+  "one",
+  "onion",
+  "online",
+  "only",
+  "open",
+  "opera",
+  "opinion",
+  "oppose",
+  "option",
+  "orange",
+  "orbit",
+  "orchard",
+  "order",
+  "ordinary",
+  "organ",
+  "orient",
+  "original",
+  "orphan",
+  "ostrich",
+  "other",
+  "outdoor",
+  "outer",
+  "output",
+  "outside",
+  "oval",
+  "oven",
+  "over",
+  "own",
+  "owner",
+  "oxygen",
+  "oyster",
+  "ozone",
+  "pact",
+  "paddle",
+  "page",
+  "pair",
+  "palace",
+  "palm",
+  "panda",
+  "panel",
+  "panic",
+  "panther",
+  "paper",
+  "parade",
+  "parent",
+  "park",
+  "parrot",
+  "party",
+  "pass",
+  "patch",
+  "path",
+  "patient",
+  "patrol",
+  "pattern",
+  "pause",
+  "pave",
+  "payment",
+  "peace",
+  "peanut",
+  "pear",
+  "peasant",
+  "pelican",
+  "pen",
+  "penalty",
+  "pencil",
+  "people",
+  "pepper",
+  "perfect",
+  "permit",
+  "person",
+  "pet",
+  "phone",
+  "photo",
+  "phrase",
+  "physical",
+  "piano",
+  "picnic",
+  "picture",
+  "piece",
+  "pig",
+  "pigeon",
+  "pill",
+  "pilot",
+  "pink",
+  "pioneer",
+  "pipe",
+  "pistol",
+  "pitch",
+  "pizza",
+  "place",
+  "planet",
+  "plastic",
+  "plate",
+  "play",
+  "please",
+  "pledge",
+  "pluck",
+  "plug",
+  "plunge",
+  "poem",
+  "poet",
+  "point",
+  "polar",
+  "pole",
+  "police",
+  "pond",
+  "pony",
+  "pool",
+  "popular",
+  "portion",
+  "position",
+  "possible",
+  "post",
+  "potato",
+  "pottery",
+  "poverty",
+  "powder",
+  "power",
+  "practice",
+  "praise",
+  "predict",
+  "prefer",
+  "prepare",
+  "present",
+  "pretty",
+  "prevent",
+  "price",
+  "pride",
+  "primary",
+  "print",
+  "priority",
+  "prison",
+  "private",
+  "prize",
+  "problem",
+  "process",
+  "produce",
+  "profit",
+  "program",
+  "project",
+  "promote",
+  "proof",
+  "property",
+  "prosper",
+  "protect",
+  "proud",
+  "provide",
+  "public",
+  "pudding",
+  "pull",
+  "pulp",
+  "pulse",
+  "pumpkin",
+  "punch",
+  "pupil",
+  "puppy",
+  "purchase",
+  "purity",
+  "purpose",
+  "purse",
+  "push",
+  "put",
+  "puzzle",
+  "pyramid",
+  "quality",
+  "quantum",
+  "quarter",
+  "question",
+  "quick",
+  "quit",
+  "quiz",
+  "quote",
+  "rabbit",
+  "raccoon",
+  "race",
+  "rack",
+  "radar",
+  "radio",
+  "rail",
+  "rain",
+  "raise",
+  "rally",
+  "ramp",
+  "ranch",
+  "random",
+  "range",
+  "rapid",
+  "rare",
+  "rate",
+  "rather",
+  "raven",
+  "raw",
+  "razor",
+  "ready",
+  "real",
+  "reason",
+  "rebel",
+  "rebuild",
+  "recall",
+  "receive",
+  "recipe",
+  "record",
+  "recycle",
+  "reduce",
+  "reflect",
+  "reform",
+  "refuse",
+  "region",
+  "regret",
+  "regular",
+  "reject",
+  "relax",
+  "release",
+  "relief",
+  "rely",
+  "remain",
+  "remember",
+  "remind",
+  "remove",
+  "render",
+  "renew",
+  "rent",
+  "reopen",
+  "repair",
+  "repeat",
+  "replace",
+  "report",
+  "require",
+  "rescue",
+  "resemble",
+  "resist",
+  "resource",
+  "response",
+  "result",
+  "retire",
+  "retreat",
+  "return",
+  "reunion",
+  "reveal",
+  "review",
+  "reward",
+  "rhythm",
+  "rib",
+  "ribbon",
+  "rice",
+  "rich",
+  "ride",
+  "ridge",
+  "rifle",
+  "right",
+  "rigid",
+  "ring",
+  "riot",
+  "ripple",
+  "risk",
+  "ritual",
+  "rival",
+  "river",
+  "road",
+  "roast",
+  "robot",
+  "robust",
+  "rocket",
+  "romance",
+  "roof",
+  "rookie",
+  "room",
+  "rose",
+  "rotate",
+  "rough",
+  "round",
+  "route",
+  "royal",
+  "rubber",
+  "rude",
+  "rug",
+  "rule",
+  "run",
+  "runway",
+  "rural",
+  "sad",
+  "saddle",
+  "sadness",
+  "safe",
+  "sail",
+  "salad",
+  "salmon",
+  "salon",
+  "salt",
+  "salute",
+  "same",
+  "sample",
+  "sand",
+  "satisfy",
+  "satoshi",
+  "sauce",
+  "sausage",
+  "save",
+  "say",
+  "scale",
+  "scan",
+  "scare",
+  "scatter",
+  "scene",
+  "scheme",
+  "school",
+  "science",
+  "scissors",
+  "scorpion",
+  "scout",
+  "scrap",
+  "screen",
+  "script",
+  "scrub",
+  "sea",
+  "search",
+  "season",
+  "seat",
+  "second",
+  "secret",
+  "section",
+  "security",
+  "seed",
+  "seek",
+  "segment",
+  "select",
+  "sell",
+  "seminar",
+  "senior",
+  "sense",
+  "sentence",
+  "series",
+  "service",
+  "session",
+  "settle",
+  "setup",
+  "seven",
+  "shadow",
+  "shaft",
+  "shallow",
+  "share",
+  "shed",
+  "shell",
+  "sheriff",
+  "shield",
+  "shift",
+  "shine",
+  "ship",
+  "shiver",
+  "shock",
+  "shoe",
+  "shoot",
+  "shop",
+  "short",
+  "shoulder",
+  "shove",
+  "shrimp",
+  "shrug",
+  "shuffle",
+  "shy",
+  "sibling",
+  "sick",
+  "side",
+  "siege",
+  "sight",
+  "sign",
+  "silent",
+  "silk",
+  "silly",
+  "silver",
+  "similar",
+  "simple",
+  "since",
+  "sing",
+  "siren",
+  "sister",
+  "situate",
+  "six",
+  "size",
+  "skate",
+  "sketch",
+  "ski",
+  "skill",
+  "skin",
+  "skirt",
+  "skull",
+  "slab",
+  "slam",
+  "sleep",
+  "slender",
+  "slice",
+  "slide",
+  "slight",
+  "slim",
+  "slogan",
+  "slot",
+  "slow",
+  "slush",
+  "small",
+  "smart",
+  "smile",
+  "smoke",
+  "smooth",
+  "snack",
+  "snake",
+  "snap",
+  "sniff",
+  "snow",
+  "soap",
+  "soccer",
+  "social",
+  "sock",
+  "soda",
+  "soft",
+  "solar",
+  "soldier",
+  "solid",
+  "solution",
+  "solve",
+  "someone",
+  "song",
+  "soon",
+  "sorry",
+  "sort",
+  "soul",
+  "sound",
+  "soup",
+  "source",
+  "south",
+  "space",
+  "spare",
+  "spatial",
+  "spawn",
+  "speak",
+  "special",
+  "speed",
+  "spell",
+  "spend",
+  "sphere",
+  "spice",
+  "spider",
+  "spike",
+  "spin",
+  "spirit",
+  "split",
+  "spoil",
+  "sponsor",
+  "spoon",
+  "sport",
+  "spot",
+  "spray",
+  "spread",
+  "spring",
+  "spy",
+  "square",
+  "squeeze",
+  "squirrel",
+  "stable",
+  "stadium",
+  "staff",
+  "stage",
+  "stairs",
+  "stamp",
+  "stand",
+  "start",
+  "state",
+  "stay",
+  "steak",
+  "steel",
+  "stem",
+  "step",
+  "stereo",
+  "stick",
+  "still",
+  "sting",
+  "stock",
+  "stomach",
+  "stone",
+  "stool",
+  "story",
+  "stove",
+  "strategy",
+  "street",
+  "strike",
+  "strong",
+  "struggle",
+  "student",
+  "stuff",
+  "stumble",
+  "style",
+  "subject",
+  "submit",
+  "subway",
+  "success",
+  "such",
+  "sudden",
+  "suffer",
+  "sugar",
+  "suggest",
+  "suit",
+  "summer",
+  "sun",
+  "sunny",
+  "sunset",
+  "super",
+  "supply",
+  "supreme",
+  "sure",
+  "surface",
+  "surge",
+  "surprise",
+  "surround",
+  "survey",
+  "suspect",
+  "sustain",
+  "swallow",
+  "swamp",
+  "swap",
+  "swarm",
+  "swear",
+  "sweet",
+  "swift",
+  "swim",
+  "swing",
+  "switch",
+  "sword",
+  "symbol",
+  "symptom",
+  "syrup",
+  "system",
+  "table",
+  "tackle",
+  "tag",
+  "tail",
+  "talent",
+  "talk",
+  "tank",
+  "tape",
+  "target",
+  "task",
+  "taste",
+  "tattoo",
+  "taxi",
+  "teach",
+  "team",
+  "tell",
+  "ten",
+  "tenant",
+  "tennis",
+  "tent",
+  "term",
+  "test",
+  "text",
+  "thank",
+  "that",
+  "theme",
+  "then",
+  "theory",
+  "there",
+  "they",
+  "thing",
+  "this",
+  "thought",
+  "three",
+  "thrive",
+  "throw",
+  "thumb",
+  "thunder",
+  "ticket",
+  "tide",
+  "tiger",
+  "tilt",
+  "timber",
+  "time",
+  "tiny",
+  "tip",
+  "tired",
+  "tissue",
+  "title",
+  "toast",
+  "tobacco",
+  "today",
+  "toddler",
+  "toe",
+  "together",
+  "toilet",
+  "token",
+  "tomato",
+  "tomorrow",
+  "tone",
+  "tongue",
+  "tonight",
+  "tool",
+  "tooth",
+  "top",
+  "topic",
+  "topple",
+  "torch",
+  "tornado",
+  "tortoise",
+  "toss",
+  "total",
+  "tourist",
+  "toward",
+  "tower",
+  "town",
+  "toy",
+  "track",
+  "trade",
+  "traffic",
+  "tragic",
+  "train",
+  "transfer",
+  "trap",
+  "trash",
+  "travel",
+  "tray",
+  "treat",
+  "tree",
+  "trend",
+  "trial",
+  "tribe",
+  "trick",
+  "trigger",
+  "trim",
+  "trip",
+  "trophy",
+  "trouble",
+  "truck",
+  "true",
+  "truly",
+  "trumpet",
+  "trust",
+  "truth",
+  "try",
+  "tube",
+  "tuition",
+  "tumble",
+  "tuna",
+  "tunnel",
+  "turkey",
+  "turn",
+  "turtle",
+  "twelve",
+  "twenty",
+  "twice",
+  "twin",
+  "twist",
+  "two",
+  "type",
+  "typical",
+  "ugly",
+  "umbrella",
+  "unable",
+  "unaware",
+  "uncle",
+  "uncover",
+  "under",
+  "undo",
+  "unfair",
+  "unfold",
+  "unhappy",
+  "uniform",
+  "unique",
+  "unit",
+  "universe",
+  "unknown",
+  "unlock",
+  "until",
+  "unusual",
+  "unveil",
+  "update",
+  "upgrade",
+  "uphold",
+  "upon",
+  "upper",
+  "upset",
+  "urban",
+  "urge",
+  "usage",
+  "use",
+  "used",
+  "useful",
+  "useless",
+  "usual",
+  "utility",
+  "vacant",
+  "vacuum",
+  "vague",
+  "valid",
+  "valley",
+  "valve",
+  "van",
+  "vanish",
+  "vapor",
+  "various",
+  "vast",
+  "vault",
+  "vehicle",
+  "velvet",
+  "vendor",
+  "venture",
+  "venue",
+  "verb",
+  "verify",
+  "version",
+  "very",
+  "vessel",
+  "veteran",
+  "viable",
+  "vibrant",
+  "vicious",
+  "victory",
+  "video",
+  "view",
+  "village",
+  "vintage",
+  "violin",
+  "virtual",
+  "virus",
+  "visa",
+  "visit",
+  "visual",
+  "vital",
+  "vivid",
+  "vocal",
+  "voice",
+  "void",
+  "volcano",
+  "volume",
+  "vote",
+  "voyage",
+  "wage",
+  "wagon",
+  "wait",
+  "walk",
+  "wall",
+  "walnut",
+  "want",
+  "warfare",
+  "warm",
+  "warrior",
+  "wash",
+  "wasp",
+  "waste",
+  "water",
+  "wave",
+  "way",
+  "wealth",
+  "weapon",
+  "wear",
+  "weasel",
+  "weather",
+  "web",
+  "wedding",
+  "weekend",
+  "weird",
+  "welcome",
+  "west",
+  "wet",
+  "whale",
+  "what",
+  "wheat",
+  "wheel",
+  "when",
+  "where",
+  "whip",
+  "whisper",
+  "wide",
+  "width",
+  "wife",
+  "wild",
+  "will",
+  "win",
+  "window",
+  "wine",
+  "wing",
+  "wink",
+  "winner",
+  "winter",
+  "wire",
+  "wisdom",
+  "wise",
+  "wish",
+  "witness",
+  "wolf",
+  "woman",
+  "wonder",
+  "wood",
+  "wool",
+  "word",
+  "work",
+  "world",
+  "worry",
+  "worth",
+  "wrap",
+  "wreck",
+  "wrestle",
+  "wrist",
+  "write",
+  "wrong",
+  "yard",
+  "year",
+  "yellow",
+  "you",
+  "young",
+  "youth",
+  "zebra",
+  "zero",
+  "zone",
+  "zoo"
+];
+
+// src/account/account.ts
+var ACCOUNT_LINK_DOMAIN = new TextEncoder().encode(
+  "calimero.mdma.account-link.v1\0"
+);
+var ENTROPY_BITS = 256;
+var CHECKSUM_BITS = ENTROPY_BITS / 32;
+var PHRASE_WORDS = (ENTROPY_BITS + CHECKSUM_BITS) / 11;
+async function generateAccountRoot() {
+  const entropy = crypto.getRandomValues(new Uint8Array(ENTROPY_BITS / 8));
+  return withPhrase(hex(entropy), await encodePhrase(entropy));
+}
+async function accountRootFromPhrase(phrase) {
+  const words = normalisePhrase(phrase);
+  return withPhrase(hex(await decodePhrase(words)), words.join(" "));
+}
+async function accountRootFromSecret(secret) {
+  fromHex(secret, "secret", 32);
+  return {
+    secret,
+    publicKey: hex(await derivePublicKey(secret)),
+    accountId: await accountForRoot(secret)
+  };
+}
+async function signAccountLink(input) {
+  if (!input.nonce) throw new Error("nonce is required to sign an account link");
+  const key = await importSigningKey(input.rootSecret);
+  const signature = new Uint8Array(
+    await crypto.subtle.sign(
+      "Ed25519",
+      key,
+      concat(ACCOUNT_LINK_DOMAIN, new TextEncoder().encode(input.nonce))
+    )
+  );
+  return base64(signature);
+}
+async function withPhrase(secret, phrase) {
+  return { ...await accountRootFromSecret(secret), phrase };
+}
+function normalisePhrase(phrase) {
+  const words = phrase.normalize("NFKD").toLowerCase().trim().split(/\s+/);
+  const count = words[0] === "" ? 0 : words.length;
+  if (count !== PHRASE_WORDS) {
+    throw new Error(
+      `recovery phrase must be ${PHRASE_WORDS} words, got ${count}`
+    );
+  }
+  return words;
+}
+async function encodePhrase(entropy) {
+  const bits = bitsOf(entropy) + await checksumBits(entropy);
+  const words = [];
+  for (let i = 0; i < PHRASE_WORDS; i += 1) {
+    const index = Number.parseInt(bits.slice(i * 11, i * 11 + 11), 2);
+    words.push(ENGLISH_WORDLIST[index]);
+  }
+  return words.join(" ");
+}
+async function decodePhrase(words) {
+  let bits = "";
+  for (const word of words) {
+    const index = ENGLISH_WORDLIST.indexOf(word);
+    if (index < 0) {
+      throw new Error(`"${word}" is not a word in the recovery phrase list`);
+    }
+    bits += index.toString(2).padStart(11, "0");
+  }
+  const entropy = new Uint8Array(ENTROPY_BITS / 8);
+  for (let i = 0; i < entropy.length; i += 1) {
+    entropy[i] = Number.parseInt(bits.slice(i * 8, i * 8 + 8), 2);
+  }
+  if (bits.slice(ENTROPY_BITS) !== await checksumBits(entropy)) {
+    throw new Error(
+      "recovery phrase checksum failed \u2014 check for a mistyped or transposed word"
+    );
+  }
+  return entropy;
+}
+async function checksumBits(entropy) {
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", entropy));
+  return bitsOf(digest).slice(0, CHECKSUM_BITS);
+}
+function bitsOf(bytes) {
+  let bits = "";
+  for (const byte of bytes) bits += byte.toString(2).padStart(8, "0");
+  return bits;
+}
+function base64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
 // src/cloud/cloud-client.ts
 var DEFAULT_CLOUD_BASE_URL = "https://cloud.calimero.network";
 var REFRESH_HEADER = "x-mdma-session-refresh";
@@ -2517,6 +4955,65 @@ var CloudClient = class {
     const relays = await this.getNamespaceRelays(namespaceId);
     return relays.find((r) => r.authorshipReady && r.relayUrl !== null && r.executorAccount !== null) ?? null;
   }
+  /**
+   * Where to reach a namespace without owning it: one read, both verbs.
+   *
+   * **Anonymous.** A joiner is by construction not the namespace owner and holds
+   * no cloud session — needing one is exactly what this path exists to avoid.
+   * Discovery is not authorization: merod refuses an `/admit` call unless the
+   * relaying node's account is on the invitation's signed `admitters` list, and
+   * refuses an intent unless the warrant is genuinely the member's, so naming a
+   * node grants the caller nothing it did not already have.
+   *
+   * A keyholder resolves a namespace to a node ONCE and then admits, reads and
+   * posts intents against that same node, which is why admission and writability
+   * are answered together rather than across two endpoints — the per-context
+   * read needs a context id a joiner does not yet have.
+   *
+   * An empty `nodes` list is a state, not an error: a namespace with no fleet
+   * assignment has no cloud node, and the joiner must use one of the
+   * invitation's other admitters — another admin's node, or a self-hosted peer.
+   */
+  async getNamespaceRouting(namespaceId) {
+    const body = await this.request("GET", `/api/cloud/namespaces/${encodeURIComponent(namespaceId)}/admitters`, {
+      anonymous: true
+    });
+    return {
+      namespaceId: String(body.namespace_id ?? namespaceId),
+      nodes: (body.admitters ?? []).map((row) => ({
+        peerId: String(row.peer_id ?? ""),
+        account: row.account ?? null,
+        relayUrl: row.relay_url ?? null,
+        admitUrl: row.admit_url ?? null,
+        status: String(row.status ?? ""),
+        fresh: row.fresh === true,
+        canAdmit: row.can_admit === true,
+        authorshipReady: row.authorship_ready === true,
+        canExecute: row.can_execute === true
+      })),
+      servable: body.servable === true,
+      writable: body.writable === true
+    };
+  }
+  /**
+   * The node to send a signed join to, chosen from those an invitation names.
+   *
+   * Pass the invitation's `admitters` and the intersection is done here, because
+   * skipping it is the failure this method exists to prevent: the cloud lists
+   * every node assigned to the namespace, while `admitters` is a snapshot signed
+   * when the invitation was minted. A node added afterwards looks perfect in
+   * every field here and answers 403.
+   *
+   * Omit `admitters` only for an invitation that names none — an empty list on
+   * the wire authorises any node to admit.
+   */
+  async findAdmitter(namespaceId, admitters) {
+    const { nodes } = await this.getNamespaceRouting(namespaceId);
+    const allowed = admitters && admitters.length > 0 ? new Set(admitters.map((a) => a.toLowerCase())) : null;
+    return nodes.find(
+      (n) => n.canAdmit && (allowed === null || n.account !== null && allowed.has(n.account.toLowerCase()))
+    ) ?? null;
+  }
   /**
    * Every attested machine currently serving something this account owns.
    *
@@ -2643,6 +5140,93 @@ var CloudClient = class {
     window.open(`${this.baseUrl}/disable-ha?${params.toString()}`);
   }
   /** Record a freshly-issued session and tell the app to persist it. */
+  /**
+   * Link a Calimero account to this cloud login, proving possession of its root.
+   *
+   * Two hops, folded into one call because they are useless apart: fetch a
+   * single-use challenge, then sign it with the account root and post the proof.
+   * The secret never leaves this process — only a signature over a nonce the
+   * cloud minted does.
+   *
+   * This is the binding the cloud bills against. A relay does not need it to run
+   * an intent; the cloud needs it to know whose plan a hosted node is spending,
+   * and to sign that account back in later.
+   *
+   * @param rootSecret the account root's signing secret, 64 hex — from
+   *   {@link generateAccountRoot}, from a restored recovery phrase, or from a
+   *   desktop app or hardware key that already holds one.
+   *
+   * Idempotent for the same login. An account already linked to a *different*
+   * cloud login is a `409`; a replayed or expired challenge is a `403`; and
+   * exceeding the plan's account limit is a `402`.
+   */
+  async linkAccount(rootSecret) {
+    const root = await accountRootFromSecret(rootSecret);
+    const { nonce } = await this.getAccountLinkChallenge();
+    return this.submitAccountLink({
+      accountId: root.accountId,
+      rootPublicKey: root.publicKey,
+      nonce,
+      signature: await signAccountLink({ rootSecret, nonce })
+    });
+  }
+  /**
+   * Mint a single-use challenge for an account root to sign.
+   *
+   * The split half of {@link linkAccount}, for the case that call cannot serve:
+   * a root held by a desktop app, a hardware key or an air-gapped machine, which
+   * signs without the secret ever reaching this process. Fetch the challenge
+   * here, have the holder sign it, then hand the proof to
+   * {@link submitAccountLink}.
+   *
+   * Bound to the signed-in login and short-lived, so it is not a standing
+   * capability if it leaks — but it IS single-use, so a challenge fetched and
+   * abandoned is spent.
+   */
+  async getAccountLinkChallenge() {
+    const body = await this.request("GET", "/api/cloud/me/accounts/challenge");
+    return { nonce: body.nonce, expiresAtMs: body.expires_at_ms ?? null };
+  }
+  /**
+   * Post a proof assembled elsewhere. The other half of
+   * {@link getAccountLinkChallenge}.
+   *
+   * `accountId` must be the account `rootPublicKey` names — the cloud refuses a
+   * valid signature by a key that names a different account, or a caller could
+   * prove one root and link somebody else's account. Derive both from the same
+   * key rather than letting a user type either.
+   */
+  async submitAccountLink(proof) {
+    const body = await this.request(
+      "POST",
+      "/api/cloud/me/accounts",
+      {
+        body: {
+          account_id: proof.accountId,
+          root_public_key: proof.rootPublicKey,
+          nonce: proof.nonce,
+          signature: proof.signature
+        }
+      }
+    );
+    return {
+      accountId: String(body.account_id ?? proof.accountId),
+      linkedAt: body.linked_at ?? null,
+      alreadyLinked: body.already_linked === true
+    };
+  }
+  /** The accounts linked to this login, and how many the plan allows. */
+  async getMyAccounts() {
+    const body = await this.request("GET", "/api/cloud/me/accounts");
+    return {
+      accounts: (body.accounts ?? []).map((row) => ({
+        accountId: String(row.account_id ?? ""),
+        linkedAt: row.linked_at ?? null,
+        hasRecoveryEnvelope: row.has_recovery_envelope === true
+      })),
+      limit: body.limit ?? null
+    };
+  }
   adoptSession(body) {
     this.session = {
       sessionToken: body.session_token,
@@ -3122,105 +5706,6 @@ var LocalStorageTokenStore = class {
   }
 };
 
-// src/crypto/internal.ts
-var PKCS8_ED25519_PREFIX = new Uint8Array([
-  48,
-  46,
-  2,
-  1,
-  0,
-  48,
-  5,
-  6,
-  3,
-  43,
-  101,
-  112,
-  4,
-  34,
-  4,
-  32
-]);
-function u32le(value) {
-  const out = new Uint8Array(4);
-  new DataView(out.buffer).setUint32(0, value, true);
-  return out;
-}
-function hex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function fromHex(value, label, expectedBytes) {
-  const clean = value.trim();
-  if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length !== expectedBytes * 2) {
-    throw new Error(
-      `${label} must be ${expectedBytes * 2} hex characters, got ${clean.length}`
-    );
-  }
-  const bytes = new Uint8Array(expectedBytes);
-  for (let i = 0; i < expectedBytes; i += 1) {
-    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function u64le(value) {
-  const out = new Uint8Array(8);
-  new DataView(out.buffer).setBigUint64(0, BigInt(value), true);
-  return out;
-}
-function concat(...parts) {
-  const out = new Uint8Array(parts.reduce((total, p) => total + p.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}
-async function domainHash(domain, parts) {
-  const chunks = [u64le(domain.length), domain];
-  for (const part of parts) {
-    chunks.push(u64le(part.length), part);
-  }
-  return new Uint8Array(
-    await crypto.subtle.digest("SHA-256", concat(...chunks))
-  );
-}
-async function importSigningKey(secretHex) {
-  const seed = fromHex(secretHex, "deviceSecret", 32);
-  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
-  try {
-    return await crypto.subtle.importKey(
-      "pkcs8",
-      pkcs8,
-      { name: "Ed25519" },
-      false,
-      ["sign"]
-    );
-  } catch (cause) {
-    const detail = cause instanceof Error ? `: ${cause.message}` : "";
-    throw new Error(
-      "this runtime has no WebCrypto Ed25519, so a warrant cannot be signed here. Node 18.4+, Safari 17+, Firefox 129+ and Chrome 137+ have it; otherwise mint the warrant with `merod account warrant`" + detail
-    );
-  }
-}
-async function derivePublicKey(secretHex) {
-  const seed = fromHex(secretHex, "deviceSecret", 32);
-  const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
-  const key = await crypto.subtle.importKey(
-    "pkcs8",
-    pkcs8,
-    { name: "Ed25519" },
-    true,
-    ["sign"]
-  );
-  const jwk = await crypto.subtle.exportKey("jwk", key);
-  const raw = jwk.x;
-  return Uint8Array.from(
-    atob(raw.replace(/-/g, "+").replace(/_/g, "/")),
-    (c) => c.charCodeAt(0)
-  );
-}
-
 // src/warrant/warrant.ts
 var SIGN_DOMAIN = new TextEncoder().encode("calimero.warrant.v2");
 var INTENT_DOMAIN = new TextEncoder().encode("calimero.warrant.intent.v1");
@@ -3521,7 +6006,7 @@ function explainNoRelay(namespace, relays) {
   }
   const waitingOnGrant = relays.filter((r) => !r.authorshipReady);
   if (waitingOnGrant.length === relays.length) {
-    return `every relay on namespace ${namespace.namespaceId} is waiting for the authorship grant: an admin of the namespace must grant CAN_AUTHOR_ON_BEHALF to ${waitingOnGrant.map((r) => r.executorAccount ?? r.peerId).join(", ") || "the relay account"}`;
+    return `every relay on namespace ${namespace.namespaceId} is waiting for the authorship grant: an admin of the namespace must grant CAN_AUTHOR_ON_BEHALF to ${waitingOnGrant.map((r) => r.executorAccount ?? r.peerId).join(", ") || "the relay account"} \u2014 with AdminClient.grantAuthorship(namespaceId, account) for these relays, and AdminClient.openToDelegatedExecution(namespaceId) so relays assigned later need no further op`;
   }
   return `namespace ${namespace.namespaceId} has ${relays.length} relay(s), but none reported both a URL and an executor account yet \u2014 retry shortly`;
 }
@@ -3534,83 +6019,6 @@ async function defaultNonceSource(deviceSecret) {
   }
 }
 
-// src/device-cert/device-cert.ts
-var CERT_DOMAIN = new TextEncoder().encode("calimero.device.cert.v1");
-var ACCOUNT_ID_DOMAIN = new TextEncoder().encode("calimero.account.genesis.v1");
-var DEVICE_ID_DOMAIN = new TextEncoder().encode("calimero.device.id.v1");
-var ACCOUNT_GENESIS_VERSION = 2;
-async function mintDeviceId(account, nonce) {
-  if (nonce.length !== 16) {
-    throw new Error(`nonce must be 16 bytes, got ${nonce.length}`);
-  }
-  const accountBytes = fromHex(account, "account", 32);
-  return hex(await domainHash(DEVICE_ID_DOMAIN, [accountBytes, nonce]));
-}
-async function deviceCertPayload(input) {
-  return domainHash(CERT_DOMAIN, [
-    fromHex(input.account, "account", 32),
-    fromHex(input.device, "device", 32),
-    fromHex(input.signPublicKey, "signPublicKey", 32),
-    fromHex(input.kemPublicKey, "kemPublicKey", 32),
-    u32le(input.keyEpoch),
-    u32le(input.deviceEpoch)
-  ]);
-}
-function accountProofBytes(input) {
-  return concat(
-    new Uint8Array([ACCOUNT_GENESIS_VERSION]),
-    input.rootPublicKey,
-    u32le(0),
-    fromHex(input.account, "account", 32),
-    fromHex(input.device, "device", 32),
-    fromHex(input.signPublicKey, "signPublicKey", 32),
-    fromHex(input.kemPublicKey, "kemPublicKey", 32),
-    u32le(input.keyEpoch),
-    u32le(input.deviceEpoch),
-    input.signature
-  );
-}
-async function signDeviceCert(input) {
-  const rootPublicKey = await derivePublicKey(input.rootSecret);
-  const account = hex(
-    await domainHash(ACCOUNT_ID_DOMAIN, [
-      concat(new Uint8Array([ACCOUNT_GENESIS_VERSION]), rootPublicKey)
-    ])
-  );
-  const keyEpoch = 0;
-  const payload = await deviceCertPayload({
-    account,
-    device: input.device,
-    signPublicKey: input.signPublicKey,
-    kemPublicKey: input.kemPublicKey,
-    keyEpoch,
-    deviceEpoch: input.deviceEpoch
-  });
-  const key = await importSigningKey(input.rootSecret);
-  const signature = new Uint8Array(
-    await crypto.subtle.sign("Ed25519", key, payload)
-  );
-  const credential = accountProofBytes({
-    rootPublicKey,
-    account,
-    device: input.device,
-    signPublicKey: input.signPublicKey,
-    kemPublicKey: input.kemPublicKey,
-    keyEpoch,
-    deviceEpoch: input.deviceEpoch,
-    signature
-  });
-  return hex(credential);
-}
-async function accountForRoot(rootSecret) {
-  const rootPublicKey = await derivePublicKey(rootSecret);
-  return hex(
-    await domainHash(ACCOUNT_ID_DOMAIN, [
-      concat(new Uint8Array([ACCOUNT_GENESIS_VERSION]), rootPublicKey)
-    ])
-  );
-}
-
 // src/namespace-op/namespace-op.ts
 var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 8;
 var NAMESPACE_SIGN_DOMAIN = new TextEncoder().encode("calimero.namespace.v1");
@@ -3885,41 +6293,6 @@ async function login(config) {
   };
 }
 
-// src/capabilities.ts
-var CAPABILITIES = {
-  CAN_CREATE_CONTEXT: 1 << 0,
-  CAN_INVITE_MEMBERS: 1 << 1,
-  CAN_JOIN_OPEN_SUBGROUPS: 1 << 2,
-  MANAGE_MEMBERS: 1 << 3,
-  MANAGE_APPLICATION: 1 << 4,
-  CAN_CREATE_SUBGROUP: 1 << 5,
-  CAN_DELETE_SUBGROUP: 1 << 6,
-  CAN_MANAGE_VISIBILITY: 1 << 7,
-  CAN_MANAGE_METADATA: 1 << 8,
-  /**
-   * Publish writes attributed to ANOTHER member, under a warrant that member
-   * signed — the grant delegated execution runs on.
-   *
-   * Implied by nothing: not by membership, not by admin, and not propagated by
-   * the subgroup-admit cascade. So every group is authorship-closed until an
-   * admin sets this bit, and a relay without it is refused at
-   * `performIntent` before anything executes. That is why it is worth naming
-   * here rather than leaving callers to write `1 << 9`: a client granting it
-   * has to be able to say what it is granting.
-   */
-  CAN_AUTHOR_ON_BEHALF: 1 << 9
-};
-function hasCap(mask, cap) {
-  const capU32 = cap >>> 0;
-  return (mask & capU32) >>> 0 === capU32;
-}
-function withCap(mask, cap) {
-  return (mask | cap) >>> 0;
-}
-function withoutCap(mask, cap) {
-  return (mask & ~cap) >>> 0;
-}
-
 // src/nodeDiscovery.ts
 var DEFAULT_LOCAL_NODE_PORTS = [2428, 2429, 2528, 2529];
 var LOCAL_HOST = "localhost";