@calimero-network/mero-js 15.0.0 → 15.2.0

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   SseClient: () => SseClient,
   WebHttpClient: () => WebHttpClient,
   WsClient: () => WsClient,
+  accountForRoot: () => accountForRoot,
   buildAuthLoginUrl: () => buildAuthLoginUrl,
   combineSignals: () => combineSignals,
   compareSemver: () => compareSemver,
@@ -53,14 +54,17 @@ __export(index_exports, {
   createRetryableMethod: () => createRetryableMethod,
   createTimeoutSignal: () => createTimeoutSignal,
   createUniversalHttpClient: () => createUniversalHttpClient,
+  deviceCertPayload: () => deviceCertPayload,
   discoverLocalNodes: () => discoverLocalNodes,
   hasCap: () => hasCap,
   intentHash: () => intentHash,
   jsonCodec: () => jsonCodec,
   localNodeUrl: () => localNodeUrl,
+  mintDeviceId: () => mintDeviceId,
   nodeEndpoint: () => nodeEndpoint,
   parseAuthCallback: () => parseAuthCallback,
   probeNodeHealth: () => probeNodeHealth,
+  signDeviceCert: () => signDeviceCert,
   signWarrant: () => signWarrant,
   withCap: () => withCap,
   withRetry: () => withRetry,
@@ -1228,6 +1232,32 @@ var AdminApiClient = class {
       )
     );
   }
+  /**
+   * Present a join this caller signed to a node the inviter named as an
+   * admitter.
+   *
+   * For a member with no node. `joinNamespace` publishes the membership op from
+   * the node making the call; this hands an already-signed op to somebody else's
+   * node to publish. The distinction matters because a keyholder has nowhere to
+   * publish from.
+   *
+   * The op must be signed by the **device key** in the credential it carries —
+   * every peer checks that when applying a join. So the admitter cannot author
+   * this, only carry it: a hostile one can refuse, and nothing else. It cannot
+   * admit a different account, change the group, or grant a role.
+   *
+   * @param namespaceId the namespace being joined, 64 hex
+   * @param request the invitation and the hex-encoded signed op
+   */
+  async admitJoin(namespaceId, request) {
+    return unwrap(
+      await this.httpClient.post(
+        `/admin-api/namespaces/${namespaceId}/admit`,
+        request,
+        { timeoutMs: 65e3 }
+      )
+    );
+  }
   async joinNamespace(namespaceId, request) {
     const data = unwrap(
       await this.httpClient.post(
@@ -2592,9 +2622,7 @@ var CloudClient = class {
   }
 };
 
-// src/warrant/warrant.ts
-var SIGN_DOMAIN = new TextEncoder().encode("calimero.warrant.v1");
-var INTENT_DOMAIN = new TextEncoder().encode("calimero.warrant.intent.v1");
+// src/crypto/internal.ts
 var PKCS8_ED25519_PREFIX = new Uint8Array([
   48,
   46,
@@ -2613,6 +2641,11 @@ var PKCS8_ED25519_PREFIX = new Uint8Array([
   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("");
 }
@@ -2652,10 +2685,6 @@ async function domainHash(domain, parts) {
     await crypto.subtle.digest("SHA-256", concat(...chunks))
   );
 }
-async function intentHash(method, argsJson) {
-  const args = new TextEncoder().encode(JSON.stringify(argsJson));
-  return domainHash(INTENT_DOMAIN, [new TextEncoder().encode(method), args]);
-}
 async function importSigningKey(secretHex) {
   const seed = fromHex(secretHex, "deviceSecret", 32);
   const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
@@ -2674,6 +2703,31 @@ async function importSigningKey(secretHex) {
     );
   }
 }
+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.v1");
+var INTENT_DOMAIN = new TextEncoder().encode("calimero.warrant.intent.v1");
+async function intentHash(method, argsJson) {
+  const args = new TextEncoder().encode(JSON.stringify(argsJson));
+  return domainHash(INTENT_DOMAIN, [new TextEncoder().encode(method), args]);
+}
 async function signWarrant(input) {
   const context = fromHex(input.context, "context", 32);
   const authorAccount = fromHex(input.authorAccount, "authorAccount", 32);
@@ -2708,21 +2762,72 @@ async function signWarrant(input) {
     )
   );
 }
-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"]
+
+// 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 = 1;
+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)
+  ]);
+}
+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 jwk = await crypto.subtle.exportKey("jwk", key);
-  const raw = jwk.x;
-  return Uint8Array.from(
-    atob(raw.replace(/-/g, "+").replace(/_/g, "/")),
-    (c) => c.charCodeAt(0)
+  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 = concat(
+    // AccountGenesis
+    new Uint8Array([ACCOUNT_GENESIS_VERSION]),
+    rootPublicKey,
+    // chain: Vec<RootKeyHandoff>, empty
+    u32le(0),
+    // DeviceCert
+    fromHex(account, "account", 32),
+    fromHex(input.device, "device", 32),
+    fromHex(input.signPublicKey, "signPublicKey", 32),
+    fromHex(input.kemPublicKey, "kemPublicKey", 32),
+    u32le(keyEpoch),
+    u32le(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)
+    ])
   );
 }