@kya-os/contracts 1.2.1 → 1.2.2

package/dist/tlkrc/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * TLKRC Module Exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rotation.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/tlkrc/rotation.d.ts

@@ -0,0 +1,246 @@
+/**
+ * TLKRC (Transparent Log Key Rotation Contract)
+ *
+ * Types for key rotation events in a transparent, auditable manner
+ *
+ * Related Spec: MCP-I Core
+ * Python Reference: Core-Documentation.md
+ */
+import { z } from 'zod';
+/**
+ * Rotation Event Schema
+ *
+ * Represents a key rotation event in a transparent log.
+ * Events form a hash-linked chain for auditability.
+ *
+ * **Dual-Key Grace Window:**
+ * During rotation, both `prevKeyId` and `nextKeyId` are valid
+ * from `effectiveAt` until `effectiveAt + grace period`.
+ */
+export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
+    /** DID of the issuer performing the rotation */
+    issuerDid: z.ZodString;
+    /** Previous key ID being rotated out */
+    prevKeyId: z.ZodString;
+    /** New key ID being rotated in */
+    nextKeyId: z.ZodString;
+    /** Timestamp when new key becomes effective (Unix seconds) */
+    effectiveAt: z.ZodNumber;
+    /** Timestamp when event was issued (Unix seconds) */
+    issuedAt: z.ZodNumber;
+    /** Sequence number (monotonically increasing) */
+    seq: z.ZodNumber;
+    /** Hash of previous rotation event (null for first rotation) */
+    prevEventHash: z.ZodOptional<z.ZodString>;
+    /** Signature over the event (using prevKeyId) */
+    signature: z.ZodString;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>, {
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export type RotationEvent = z.infer<typeof RotationEventSchema>;
+/**
+ * Rotation Chain
+ *
+ * Represents a chain of rotation events
+ */
+export declare const RotationChainSchema: z.ZodObject<{
+    /** Issuer DID */
+    issuerDid: z.ZodString;
+    /** All rotation events in order */
+    events: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** DID of the issuer performing the rotation */
+        issuerDid: z.ZodString;
+        /** Previous key ID being rotated out */
+        prevKeyId: z.ZodString;
+        /** New key ID being rotated in */
+        nextKeyId: z.ZodString;
+        /** Timestamp when new key becomes effective (Unix seconds) */
+        effectiveAt: z.ZodNumber;
+        /** Timestamp when event was issued (Unix seconds) */
+        issuedAt: z.ZodNumber;
+        /** Sequence number (monotonically increasing) */
+        seq: z.ZodNumber;
+        /** Hash of previous rotation event (null for first rotation) */
+        prevEventHash: z.ZodOptional<z.ZodString>;
+        /** Signature over the event (using prevKeyId) */
+        signature: z.ZodString;
+        /** Optional metadata */
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>, {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>, "many">;
+    /** Current active key ID */
+    currentKeyId: z.ZodString;
+    /** Whether chain is valid */
+    valid: z.ZodBoolean;
+    /** Optional validation errors */
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    issuerDid: string;
+    events: {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    currentKeyId: string;
+    errors?: string[] | undefined;
+}, {
+    valid: boolean;
+    issuerDid: string;
+    events: {
+        signature: string;
+        issuerDid: string;
+        prevKeyId: string;
+        nextKeyId: string;
+        effectiveAt: number;
+        issuedAt: number;
+        seq: number;
+        prevEventHash?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+    currentKeyId: string;
+    errors?: string[] | undefined;
+}>;
+export type RotationChain = z.infer<typeof RotationChainSchema>;
+/**
+ * Validation Helpers
+ */
+/**
+ * Validate a rotation event
+ *
+ * @param event - The event to validate
+ * @returns Validation result
+ */
+export declare function validateRotationEvent(event: unknown): z.SafeParseReturnType<{
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    signature: string;
+    issuerDid: string;
+    prevKeyId: string;
+    nextKeyId: string;
+    effectiveAt: number;
+    issuedAt: number;
+    seq: number;
+    prevEventHash?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+/**
+ * Validate rotation chain integrity
+ *
+ * @param chain - The chain to validate
+ * @returns true if chain is valid
+ */
+export declare function isRotationChainValid(chain: RotationChain): boolean;
+/**
+ * Get active key at a specific timestamp
+ *
+ * @param chain - The rotation chain
+ * @param timestamp - Timestamp in seconds
+ * @returns Active key ID at that time, or null if none
+ */
+export declare function getActiveKeyAt(chain: RotationChain, timestamp: number): string | null;
+/**
+ * Constants
+ */
+/**
+ * Default grace period for dual-key validity (24 hours)
+ */
+export declare const DEFAULT_GRACE_PERIOD_SEC: number;
+/**
+ * Maximum reasonable grace period (30 days)
+ */
+export declare const MAX_GRACE_PERIOD_SEC: number;
+//# sourceMappingURL=rotation.d.ts.map

package/dist/tlkrc/rotation.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * TLKRC (Transparent Log Key Rotation Contract)
+ *
+ * Types for key rotation events in a transparent, auditable manner
+ *
+ * Related Spec: MCP-I Core
+ * Python Reference: Core-Documentation.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_GRACE_PERIOD_SEC = exports.DEFAULT_GRACE_PERIOD_SEC = exports.RotationChainSchema = exports.RotationEventSchema = void 0;
+exports.validateRotationEvent = validateRotationEvent;
+exports.isRotationChainValid = isRotationChainValid;
+exports.getActiveKeyAt = getActiveKeyAt;
+const zod_1 = require("zod");
+/**
+ * Rotation Event Schema
+ *
+ * Represents a key rotation event in a transparent log.
+ * Events form a hash-linked chain for auditability.
+ *
+ * **Dual-Key Grace Window:**
+ * During rotation, both `prevKeyId` and `nextKeyId` are valid
+ * from `effectiveAt` until `effectiveAt + grace period`.
+ */
+exports.RotationEventSchema = zod_1.z.object({
+    /** DID of the issuer performing the rotation */
+    issuerDid: zod_1.z.string().min(1),
+    /** Previous key ID being rotated out */
+    prevKeyId: zod_1.z.string().min(1),
+    /** New key ID being rotated in */
+    nextKeyId: zod_1.z.string().min(1),
+    /** Timestamp when new key becomes effective (Unix seconds) */
+    effectiveAt: zod_1.z.number().int().positive(),
+    /** Timestamp when event was issued (Unix seconds) */
+    issuedAt: zod_1.z.number().int().positive(),
+    /** Sequence number (monotonically increasing) */
+    seq: zod_1.z.number().int().nonnegative(),
+    /** Hash of previous rotation event (null for first rotation) */
+    prevEventHash: zod_1.z.string().optional(),
+    /** Signature over the event (using prevKeyId) */
+    signature: zod_1.z.string().min(1),
+    /** Optional metadata */
+    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+}).refine((event) => event.effectiveAt >= event.issuedAt, {
+    message: 'effectiveAt must be >= issuedAt',
+});
+/**
+ * Rotation Chain
+ *
+ * Represents a chain of rotation events
+ */
+exports.RotationChainSchema = zod_1.z.object({
+    /** Issuer DID */
+    issuerDid: zod_1.z.string().min(1),
+    /** All rotation events in order */
+    events: zod_1.z.array(exports.RotationEventSchema).min(1),
+    /** Current active key ID */
+    currentKeyId: zod_1.z.string().min(1),
+    /** Whether chain is valid */
+    valid: zod_1.z.boolean(),
+    /** Optional validation errors */
+    errors: zod_1.z.array(zod_1.z.string()).optional(),
+});
+/**
+ * Validation Helpers
+ */
+/**
+ * Validate a rotation event
+ *
+ * @param event - The event to validate
+ * @returns Validation result
+ */
+function validateRotationEvent(event) {
+    return exports.RotationEventSchema.safeParse(event);
+}
+/**
+ * Validate rotation chain integrity
+ *
+ * @param chain - The chain to validate
+ * @returns true if chain is valid
+ */
+function isRotationChainValid(chain) {
+    if (chain.events.length === 0) {
+        return false;
+    }
+    // Check sequence numbers are monotonic
+    for (let i = 1; i < chain.events.length; i++) {
+        if (chain.events[i].seq <= chain.events[i - 1].seq) {
+            return false;
+        }
+    }
+    return chain.valid;
+}
+/**
+ * Get active key at a specific timestamp
+ *
+ * @param chain - The rotation chain
+ * @param timestamp - Timestamp in seconds
+ * @returns Active key ID at that time, or null if none
+ */
+function getActiveKeyAt(chain, timestamp) {
+    if (chain.events.length === 0) {
+        return null;
+    }
+    // Find the most recent event that's effective at the timestamp
+    for (let i = chain.events.length - 1; i >= 0; i--) {
+        const event = chain.events[i];
+        if (event.effectiveAt <= timestamp) {
+            return event.nextKeyId;
+        }
+    }
+    // If no event is effective yet, use the initial key
+    return chain.events[0].prevKeyId;
+}
+/**
+ * Constants
+ */
+/**
+ * Default grace period for dual-key validity (24 hours)
+ */
+exports.DEFAULT_GRACE_PERIOD_SEC = 24 * 60 * 60;
+/**
+ * Maximum reasonable grace period (30 days)
+ */
+exports.MAX_GRACE_PERIOD_SEC = 30 * 24 * 60 * 60;
+//# sourceMappingURL=rotation.js.map

package/dist/vc/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Verifiable Credentials Module Exports
+ *
+ * W3C Verifiable Credentials types, schemas, and utilities
+ */
+export * from './schemas.js';
+export * from './statuslist.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vc/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Verifiable Credentials Module Exports
+ *
+ * W3C Verifiable Credentials types, schemas, and utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas.js"), exports);
+__exportStar(require("./statuslist.js"), exports);
+//# sourceMappingURL=index.js.map