@calimero-network/mero-js 22.9.0 → 23.1.0

package/dist/warrant/governance-op.js

@@ -36,13 +36,22 @@ const GROUP_OP = {
     MemberRemoved: 2,
     MemberLeft: 3,
     MemberRoleSet: 4,
+    MemberCapabilitySet: 5,
     DefaultCapabilitiesSet: 6,
+    ContextDetached: 9,
+    SubgroupVisibilitySet: 10,
+    GroupMetadataSet: 11,
+    MemberMetadataSet: 12,
+    ContextMetadataSet: 13,
+    ContextCapabilityGranted: 16,
+    ContextCapabilityRevoked: 17,
 };
 /** `RootOp` discriminants, by position in core's enum. */
 const ROOT_OP = {
     GroupCreated: 0,
     GroupReparented: 1,
     GroupDeleted: 2,
+    MemberJoinedOpen: 7,
     NamespaceCreatedV2: 9,
 };
 /** core's `NAMESPACE_ID_DOMAIN`, which a founded namespace id is hashed under. */
@@ -100,6 +109,26 @@ export function memberRoleSetOp(member, memberRole) {
         bytes: concat(tag(GROUP_OP.MemberRoleSet), fromHex(member, 'member', 32), role(memberRole)),
     };
 }
+/** Domain of core's `created_subgroup_id`. */
+const SUBGROUP_ID_DOMAIN = new TextEncoder().encode('calimero.subgroup.id.v1');
+/**
+ * The id `admin` derives for a subgroup under `parentId` with birth visibility
+ * `restricted` and `salt` (all hex), as core's `created_subgroup_id` does:
+ * `domain_hash("calimero.subgroup.id.v1", [admin, parentId, [restricted], salt])`.
+ *
+ * A subgroup's id is bound to its create, so nobody but its creator can name
+ * it: a node refuses a `GroupCreated` whose fields do not reproduce its id.
+ * That is what stops a second member racing a concurrent create for an id it
+ * saw gossiped.
+ */
+export async function createdSubgroupId(admin, parentId, restricted, salt) {
+    return hex(await domainHash(SUBGROUP_ID_DOMAIN, [
+        fromHex(admin, 'admin', 32),
+        fromHex(parentId, 'parentId', 32),
+        new Uint8Array([restricted ? 1 : 0]),
+        fromHex(salt, 'salt', 32),
+    ]));
+}
 /**
  * Set the group's default capability mask (`MemberCapabilities` bits, a `u32`),
  * the capabilities every member holds without a per-member grant. Needs admin.
@@ -130,9 +159,18 @@ export function defaultCapabilitiesSetOp(capabilities) {
 export function groupCreatedOp(input) {
     return {
         kind: 'root',
-        bytes: concat(tag(ROOT_OP.GroupCreated), fromHex(input.groupId, 'groupId', 32), fromHex(input.parentId, 'parentId', 32), tag(input.restricted ? 1 : 0), fromHex(input.admin, 'admin', 32)),
+        bytes: concat(tag(ROOT_OP.GroupCreated), fromHex(input.groupId, 'groupId', 32), fromHex(input.parentId, 'parentId', 32), tag(input.restricted ? 1 : 0), fromHex(input.admin, 'admin', 32), fromHex(input.salt, 'salt', 32)),
     };
 }
+/**
+ * Create a subgroup under `parentId`: draws a fresh salt (unless one is given),
+ * derives the id with {@link createdSubgroupId}, and encodes the op.
+ */
+export async function subgroupCreation(input) {
+    const salt = input.salt ?? hex(crypto.getRandomValues(new Uint8Array(32)));
+    const groupId = await createdSubgroupId(input.admin, input.parentId, input.restricted, salt);
+    return { groupId, salt, op: groupCreatedOp({ ...input, groupId, salt }) };
+}
 /** Move `childGroupId` under `newParentId`, a root op. */
 export function groupReparentedOp(childGroupId, newParentId) {
     return {
@@ -183,3 +221,109 @@ export function namespaceCreatedOp(input) {
         bytes: concat(tag(ROOT_OP.NamespaceCreatedV2), fromHex(input.founder, 'founder', 32), credential, fromHex(input.salt, 'salt', 32)),
     };
 }
+// ---------------------------------------------------------------------------
+// The rest of the delegable set. Layouts are pinned against core's
+// `delegable_governance_op_vectors_for_non_rust_encoders_are_stable`
+// (crates/governance-types/src/tests.rs, core#4272).
+/** A borsh `String`: a u32 byte length, then the UTF-8 bytes. */
+function str(value) {
+    const bytes = new TextEncoder().encode(value);
+    return concat(u32le(bytes.length), bytes);
+}
+/** A borsh `Option<String>`: 0, or 1 then the string. */
+function optionalStr(value) {
+    return value === undefined ? tag(0) : concat(tag(1), str(value));
+}
+/**
+ * A borsh `BTreeMap<String, String>`: a u32 count, then each entry in the
+ * map's own order, which is by key BYTES (not JS string order).
+ */
+function stringMap(data = {}) {
+    const enc = new TextEncoder();
+    const entries = Object.entries(data)
+        .map(([k, v]) => [enc.encode(k), v, k])
+        .sort(([a], [b]) => {
+        for (let i = 0; i < Math.min(a.length, b.length); i++)
+            if (a[i] !== b[i])
+                return a[i] - b[i];
+        return a.length - b.length;
+    });
+    return concat(u32le(entries.length), ...entries.flatMap(([, v, k]) => [str(k), str(v)]));
+}
+/** Validate a u32 capability mask a relay may carry: never bit 9. */
+function relayableMask(capabilities, what) {
+    if (!Number.isInteger(capabilities) || capabilities < 0 || capabilities > 4294967295) {
+        throw new Error(`${what} must be a u32 bit mask, got ${String(capabilities)}`);
+    }
+    if (hasCap(capabilities, CAPABILITIES.CAN_AUTHOR_ON_BEHALF)) {
+        throw new Error(`${what} may not include CAN_AUTHOR_ON_BEHALF (512): a relay never carries a change to it`);
+    }
+    return capabilities;
+}
+/** Set `member`'s capabilities in the group (`GroupOp::MemberCapabilitySet`). Bit 9 is refused. */
+export function memberCapabilitySetOp(member, capabilities) {
+    return {
+        kind: 'group',
+        bytes: concat(tag(GROUP_OP.MemberCapabilitySet), fromHex(member, 'member', 32), u32le(relayableMask(capabilities, 'capabilities'))),
+    };
+}
+/** Detach a context from the group (`GroupOp::ContextDetached`). */
+export function contextDetachedOp(contextId) {
+    return { kind: 'group', bytes: concat(tag(GROUP_OP.ContextDetached), fromHex(contextId, 'contextId', 32)) };
+}
+/** Make a subgroup open (members of the parent may join it themselves) or restricted. */
+export function subgroupVisibilitySetOp(mode) {
+    if (mode !== 'open' && mode !== 'restricted')
+        throw new Error(`mode must be open or restricted, got ${String(mode)}`);
+    return { kind: 'group', bytes: concat(tag(GROUP_OP.SubgroupVisibilitySet), tag(mode === 'open' ? 0 : 1)) };
+}
+/** Name the group, with optional key/value data (`GroupOp::GroupMetadataSet`). */
+export function groupMetadataSetOp(input = {}) {
+    return { kind: 'group', bytes: concat(tag(GROUP_OP.GroupMetadataSet), optionalStr(input.name), stringMap(input.data)) };
+}
+/** Name a member in the group (`GroupOp::MemberMetadataSet`). */
+export function memberMetadataSetOp(member, input = {}) {
+    return {
+        kind: 'group',
+        bytes: concat(tag(GROUP_OP.MemberMetadataSet), fromHex(member, 'member', 32), optionalStr(input.name), stringMap(input.data)),
+    };
+}
+/** Name a context in the group (`GroupOp::ContextMetadataSet`). */
+export function contextMetadataSetOp(contextId, input = {}) {
+    return {
+        kind: 'group',
+        bytes: concat(tag(GROUP_OP.ContextMetadataSet), fromHex(contextId, 'contextId', 32), optionalStr(input.name), stringMap(input.data)),
+    };
+}
+function contextCapability(capability) {
+    if (!Number.isInteger(capability) || capability < 1 || capability > 0xff) {
+        throw new Error(`capability must be a non-zero u8, got ${String(capability)}`);
+    }
+    return tag(capability);
+}
+/** Grant `member` a per-context capability (`GroupOp::ContextCapabilityGranted`). */
+export function contextCapabilityGrantedOp(contextId, member, capability) {
+    return {
+        kind: 'group',
+        bytes: concat(tag(GROUP_OP.ContextCapabilityGranted), fromHex(contextId, 'contextId', 32), fromHex(member, 'member', 32), contextCapability(capability)),
+    };
+}
+/** Revoke a per-context capability from `member` (`GroupOp::ContextCapabilityRevoked`). */
+export function contextCapabilityRevokedOp(contextId, member, capability) {
+    return {
+        kind: 'group',
+        bytes: concat(tag(GROUP_OP.ContextCapabilityRevoked), fromHex(contextId, 'contextId', 32), fromHex(member, 'member', 32), contextCapability(capability)),
+    };
+}
+/**
+ * Join an open subgroup yourself (`RootOp::MemberJoinedOpen`), a root op posted
+ * to the namespace. `member` must be the author; `credential` is the author's
+ * own `AccountProof<DeviceCert>`, hex, carried as-is. The author's
+ * `CAN_JOIN_OPEN_SUBGROUPS` and the open inheritance path are checked as usual.
+ */
+export function memberJoinedOpenOp(input) {
+    return {
+        kind: 'root',
+        bytes: concat(tag(ROOT_OP.MemberJoinedOpen), fromHex(input.member, 'member', 32), fromHex(input.groupId, 'groupId', 32), fromHexUnsized(input.credential, 'credential')),
+    };
+}

package/dist/warrant/index.d.ts

@@ -4,5 +4,5 @@ export { signCreationWarrant, parseCreationWarrant, creationInitHash, } from './
 export type { CreationWarrantInput, CreationWarrantFields, SignedCreationWarrant, } from './creation-warrant.js';
 export { signGovernanceWarrant, parseGovernanceWarrant, governanceOpHash, } from './governance-warrant.js';
 export type { GovernanceWarrantInput, GovernanceWarrantFields, } from './governance-warrant.js';
-export { memberAddedOp, memberRemovedOp, memberLeftOp, memberRoleSetOp, groupCreatedOp, groupReparentedOp, groupDeletedOp, namespaceCreatedOp, defaultCapabilitiesSetOp, foundedNamespaceId, } from './governance-op.js';
-export type { GovernanceOp, GovernanceOpKind, GovernanceMemberRole, GroupCreatedInput, NamespaceCreatedInput, } from './governance-op.js';
+export { memberAddedOp, memberRemovedOp, memberLeftOp, memberRoleSetOp, groupCreatedOp, createdSubgroupId, subgroupCreation, groupReparentedOp, groupDeletedOp, memberCapabilitySetOp, contextDetachedOp, subgroupVisibilitySetOp, groupMetadataSetOp, memberMetadataSetOp, contextMetadataSetOp, contextCapabilityGrantedOp, contextCapabilityRevokedOp, memberJoinedOpenOp, namespaceCreatedOp, defaultCapabilitiesSetOp, foundedNamespaceId, } from './governance-op.js';
+export type { GovernanceOp, GovernanceOpKind, GovernanceMemberRole, GroupCreatedInput, SubgroupCreation, NamespaceCreatedInput, } from './governance-op.js';

package/dist/warrant/index.js

@@ -2,4 +2,4 @@
 export { signWarrant, intentHash } from './warrant.js';
 export { signCreationWarrant, parseCreationWarrant, creationInitHash, } from './creation-warrant.js';
 export { signGovernanceWarrant, parseGovernanceWarrant, governanceOpHash, } from './governance-warrant.js';
-export { memberAddedOp, memberRemovedOp, memberLeftOp, memberRoleSetOp, groupCreatedOp, groupReparentedOp, groupDeletedOp, namespaceCreatedOp, defaultCapabilitiesSetOp, foundedNamespaceId, } from './governance-op.js';
+export { memberAddedOp, memberRemovedOp, memberLeftOp, memberRoleSetOp, groupCreatedOp, createdSubgroupId, subgroupCreation, groupReparentedOp, groupDeletedOp, memberCapabilitySetOp, contextDetachedOp, subgroupVisibilitySetOp, groupMetadataSetOp, memberMetadataSetOp, contextMetadataSetOp, contextCapabilityGrantedOp, contextCapabilityRevokedOp, memberJoinedOpenOp, namespaceCreatedOp, defaultCapabilitiesSetOp, foundedNamespaceId, } from './governance-op.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calimero-network/mero-js",
-  "version": "22.9.0",
+  "version": "23.1.0",
   "description": "Pure JavaScript SDK for Calimero",
   "type": "module",
   "exports": {