@calimero-network/mero-js 15.1.0 → 15.3.0

package/dist/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   MeroJs: () => MeroJs,
   RpcClient: () => RpcClient,
   RpcError: () => RpcError,
+  SIGNED_NAMESPACE_OP_SCHEMA_VERSION: () => SIGNED_NAMESPACE_OP_SCHEMA_VERSION,
   SseClient: () => SseClient,
   WebHttpClient: () => WebHttpClient,
   WsClient: () => WsClient,
@@ -56,6 +57,7 @@ __export(index_exports, {
   createUniversalHttpClient: () => createUniversalHttpClient,
   deviceCertPayload: () => deviceCertPayload,
   discoverLocalNodes: () => discoverLocalNodes,
+  encodeSignedInvitation: () => encodeSignedInvitation,
   hasCap: () => hasCap,
   intentHash: () => intentHash,
   jsonCodec: () => jsonCodec,
@@ -65,6 +67,7 @@ __export(index_exports, {
   parseAuthCallback: () => parseAuthCallback,
   probeNodeHealth: () => probeNodeHealth,
   signDeviceCert: () => signDeviceCert,
+  signMemberJoinOp: () => signMemberJoinOp,
   signWarrant: () => signWarrant,
   withCap: () => withCap,
   withRetry: () => withRetry,
@@ -1232,6 +1235,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(
@@ -2759,6 +2788,20 @@ async function deviceCertPayload(input) {
     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(
@@ -2779,21 +2822,16 @@ async function signDeviceCert(input) {
   const signature = new Uint8Array(
     await crypto.subtle.sign("Ed25519", key, payload)
   );
-  const credential = concat(
-    // AccountGenesis
-    new Uint8Array([ACCOUNT_GENESIS_VERSION]),
+  const credential = accountProofBytes({
     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),
+    account,
+    device: input.device,
+    signPublicKey: input.signPublicKey,
+    kemPublicKey: input.kemPublicKey,
+    keyEpoch,
+    deviceEpoch: input.deviceEpoch,
     signature
-  );
+  });
   return hex(credential);
 }
 async function accountForRoot(rootSecret) {
@@ -2805,6 +2843,107 @@ async function accountForRoot(rootSecret) {
   );
 }
 
+// src/namespace-op/namespace-op.ts
+var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 7;
+var NAMESPACE_SIGN_DOMAIN = new TextEncoder().encode("calimero.namespace.v1");
+var NAMESPACE_OP_ROOT = 0;
+var ROOT_OP = {
+  GroupCreated: 0,
+  GroupReparented: 1,
+  GroupDeleted: 2,
+  AdminChanged: 3,
+  PolicyUpdated: 4,
+  MemberJoined: 5,
+  KeyDelivery: 6,
+  MemberJoinedOpen: 7,
+  MemberJoinedAt: 8,
+  NamespaceCreated: 9,
+  MemberJoinedViaTeeAttestation: 10
+};
+function bytes32(value, label) {
+  if (value.length !== 32) {
+    throw new Error(`${label} must be 32 bytes, got ${value.length}`);
+  }
+  return new Uint8Array(value);
+}
+function optionalBytes32(value, label) {
+  if (value === null || value === void 0) {
+    return new Uint8Array([0]);
+  }
+  if (value.length !== 32) {
+    throw new Error(`${label} must be 32 bytes, got ${value.length}`);
+  }
+  return concat(new Uint8Array([1]), new Uint8Array(value));
+}
+function borshString(value) {
+  const bytes = new TextEncoder().encode(value);
+  return concat(u32le(bytes.length), bytes);
+}
+function encodeAdmitterHint(hint) {
+  if ("multiaddr" in hint) {
+    return concat(new Uint8Array([0]), borshString(hint.multiaddr));
+  }
+  return concat(new Uint8Array([1]), borshString(hint.url));
+}
+function encodeSignedInvitation(signed) {
+  const body = signed.invitation;
+  const admitters = body.admitters ?? [];
+  const hints = signed.admitter_hints ?? [];
+  return concat(
+    // GroupInvitationFromAdmin.
+    //
+    // `SignerId` and `ContextGroupId` cross JSON as 32 numbers; `AccountId`
+    // crosses as hex. Same width, different spelling, and reading either the
+    // wrong way yields 32 bytes that encode cleanly and verify as nothing.
+    bytes32(body.inviter_identity, "inviter_identity"),
+    bytes32(body.group_id, "group_id"),
+    u64le(body.expiration_timestamp),
+    bytes32(body.secret_salt, "secret_salt"),
+    new Uint8Array([body.invited_role]),
+    u32le(admitters.length),
+    ...admitters.map((a, i) => fromHex(a, `admitters[${i}]`, 32)),
+    // ...then the enclosing SignedGroupOpenInvitation, in declaration order.
+    // `inviter_account` sits between the signature and the hints; putting it
+    // anywhere else still encodes 32 bytes and still verifies as nothing.
+    borshString(signed.inviter_signature),
+    signed.inviter_account ? concat(new Uint8Array([1]), fromHex(signed.inviter_account, "inviter_account", 32)) : new Uint8Array([0]),
+    u32le(hints.length),
+    ...hints.map(encodeAdmitterHint),
+    optionalBytes32(signed.application_id, "application_id"),
+    // Borsh order follows core's field order, where this is `bytecode_id`; the
+    // JSON key is `app_key`, a rename covering both directions that core pins in
+    // a test. Encoding by the Rust name would read `undefined` and emit a None
+    // where the inviter signed a Some.
+    optionalBytes32(signed.app_key, "app_key")
+  );
+}
+async function signMemberJoinOp(input) {
+  const parents = input.parentOpHashes ?? [];
+  const credential = fromHex(input.credential, "credential", input.credential.length / 2);
+  const rootOp = concat(
+    new Uint8Array([input.at ? ROOT_OP.MemberJoinedAt : ROOT_OP.MemberJoined]),
+    fromHex(input.member, "member", 32),
+    encodeSignedInvitation(input.invitation),
+    credential
+  );
+  const op = concat(new Uint8Array([NAMESPACE_OP_ROOT]), rootOp);
+  const key = await importSigningKey(input.deviceSecret);
+  const signer = await derivePublicKey(input.deviceSecret);
+  const signable = concat(
+    new Uint8Array([SIGNED_NAMESPACE_OP_SCHEMA_VERSION]),
+    fromHex(input.namespaceId, "namespaceId", 32),
+    u32le(parents.length),
+    ...parents.map((p, i) => fromHex(p, `parentOpHashes[${i}]`, 32)),
+    signer,
+    u64le(input.nonce),
+    op
+  );
+  const signature = new Uint8Array(
+    await crypto.subtle.sign("Ed25519", key, concat(NAMESPACE_SIGN_DOMAIN, signable))
+  );
+  return hex(concat(signable, signature));
+}
+
 // src/capabilities.ts
 var CAPABILITIES = {
   CAN_CREATE_CONTEXT: 1 << 0,