@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/hlc.test.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hlc_1 = require("./hlc");
-const peer_device_1 = require("./types/peer-device");
-describe("HybridLogicalClock", () => {
-    it("is monotonic when now goes backward", () => {
-        let t = 1000;
-        const clock = new hlc_1.HybridLogicalClock({ now: () => t });
-        const first = clock.tick();
-        t = 100;
-        const second = clock.tick();
-        expect(second).toBe(first + 1);
-    });
-    it("advances by 1 on the same millisecond", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 5000 });
-        expect(clock.tick()).toBe(5000);
-        expect(clock.tick()).toBe(5001);
-        expect(clock.tick()).toBe(5002);
-    });
-    it("observe advances last so the next tick is after the observed time", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 1000 });
-        expect(clock.observe(2500)).toBe(true);
-        expect(clock.tick()).toBe(2501);
-    });
-    it("observe ignores timestamps beyond the skew bound", () => {
-        const now = 10_000;
-        const clock = new hlc_1.HybridLogicalClock({ now: () => now });
-        const future = now + peer_device_1.PeerDeviceConsts.CHANGE_TIMESTAMP_TOLERANCE_MS + 1;
-        expect(clock.observe(future)).toBe(false);
-        expect(clock.tick()).toBe(now);
-    });
-    it("seed raises last without going backward", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 1000 });
-        clock.seed(2000);
-        clock.seed(1500);
-        expect(clock.tick()).toBe(2001);
-    });
-    it("now peeks physical time without advancing", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 42 });
-        expect(clock.now()).toBe(42);
-        expect(clock.now()).toBe(42);
-        expect(clock.value).toBe(0);
-        expect(clock.tick()).toBe(42);
-    });
-});

package/dist/host-credentials.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/host-credentials.test.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const host_credentials_1 = require("./host-credentials");
-const keys_1 = require("./keys");
-const utils_1 = require("./utils");
-describe("host credential record", () => {
-    const userId = (0, utils_1.newid)();
-    const k1 = (0, keys_1.newKeys)();
-    const k2 = (0, keys_1.newKeys)();
-    it("parses the legacy userId::secretKey form and derives the legacy db secret", () => {
-        const record = (0, host_credentials_1.parseCredentialRecord)(`${userId}::${k1.secretKey}`);
-        expect(record).toEqual({
-            userId,
-            secretKey: k1.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-        });
-        expect((0, host_credentials_1.legacyDbSecret)(k1.secretKey)).toBe((0, keys_1.hashValue)(k1.secretKey));
-    });
-    it("parses the JSON form, filling a missing dbSecret with the legacy value", () => {
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({ userId, secretKey: k1.secretKey }))).toEqual({
-            userId,
-            secretKey: k1.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-        });
-        const full = {
-            userId,
-            secretKey: k2.secretKey,
-            dbSecret: "db",
-            previousPublicKeys: [{ publicKey: k1.publicKey, replacedAt: "2026-10-02T00:00:00.000Z" }],
-        };
-        expect((0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(full))).toEqual(full);
-    });
-    it("returns null for garbage", () => {
-        expect((0, host_credentials_1.parseCredentialRecord)(null)).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("{not json")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({ userId }))).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("::")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("nosep")).toBeNull();
-    });
-    it("mints a random dbSecret only when asked", () => {
-        const fresh = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey }, { freshDbSecret: true });
-        expect(fresh.dbSecret).not.toBe((0, keys_1.hashValue)(k1.secretKey));
-        expect(fresh.dbSecret.length).toBeGreaterThan(30);
-        const kept = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey, dbSecret: "keep" }, {
-            freshDbSecret: true,
-        });
-        expect(kept.dbSecret).toBe("keep");
-    });
-    it("rotates the secret while keeping dbSecret and remembering the old key", () => {
-        const current = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey });
-        const at = new Date("2026-10-03T00:00:00.000Z");
-        const rotated = (0, host_credentials_1.rotateCredentialRecord)(current, {
-            secretKey: k2.secretKey,
-            oldPublicKey: k1.publicKey,
-            reason: "compromised",
-            at,
-        });
-        expect(rotated).toEqual({
-            userId,
-            secretKey: k2.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-            previousPublicKeys: [
-                { publicKey: k1.publicKey, replacedAt: at.toISOString(), reason: "compromised" },
-            ],
-            rewrapFrom: { publicKey: k1.publicKey, secretKey: k1.secretKey },
-        });
-    });
-    it("keeps the retired secret through storage until the re-wrap is finished", () => {
-        // Secrets in the personal database are re-wrapped one by one after the new key is stored.
-        // A crash in between must not lose the only key that can still open the rest.
-        const rotated = (0, host_credentials_1.rotateCredentialRecord)((0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey }), { secretKey: k2.secretKey, oldPublicKey: k1.publicKey });
-        const stored = (0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(rotated));
-        expect(stored?.rewrapFrom).toEqual({ publicKey: k1.publicKey, secretKey: k1.secretKey });
-        expect(stored?.secretKey).toBe(k2.secretKey);
-        const finished = (0, host_credentials_1.completeCredentialRewrap)(rotated);
-        expect(finished.rewrapFrom).toBeUndefined();
-        expect(finished.secretKey).toBe(k2.secretKey);
-        expect(finished.previousPublicKeys).toEqual(rotated.previousPublicKeys);
-        expect((0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(finished))?.rewrapFrom).toBeUndefined();
-        // A half-written slot is not a key to re-wrap from.
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({
-            userId,
-            secretKey: k2.secretKey,
-            rewrapFrom: { publicKey: k1.publicKey },
-        }))?.rewrapFrom).toBeUndefined();
-    });
-});

package/dist/identity/account-email.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/identity/account-email.test.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const account_email_1 = require("./account-email");
-describe("account email statements", () => {
-    const keys = (0, keys_1.newKeys)();
-    const userId = "00maccountemailstatements";
-    const issuedAt = new Date().toISOString();
-    const bind = (0, account_email_1.signEmailBind)({ purpose: "peers-account-email-bind", userId, email: "ada@example.com", issuedAt }, keys.secretKey);
-    const status = (0, account_email_1.signEmailStatus)({ purpose: "peers-account-email-status", userId, issuedAt }, keys.secretKey);
-    const unbind = (0, account_email_1.signEmailUnbind)({ purpose: "peers-account-email-unbind", userId, issuedAt }, keys.secretKey);
-    it("accepts each statement for the purpose it was signed for", () => {
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId,
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(true);
-        expect((0, account_email_1.verifyEmailStatus)({ signed: status, userId, recordPublicKey: keys.publicKey })).toBe(true);
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: unbind, userId, recordPublicKey: keys.publicKey })).toBe(true);
-    });
-    it("does not let a statement signed for one purpose stand in for another", () => {
-        // A captured read request must not be able to remove the mailbox or bind a new one.
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: status, userId, recordPublicKey: keys.publicKey })).toBe(false);
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: status,
-            userId,
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailStatus)({ signed: unbind, userId, recordPublicKey: keys.publicKey })).toBe(false);
-    });
-    it("refuses a statement for another user, another mailbox, or from another key", () => {
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId: "00maccountemailotheruser0",
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId,
-            email: "eve@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: unbind, userId, recordPublicKey: (0, keys_1.newKeys)().publicKey })).toBe(false);
-    });
-    it("refuses a statement whose contents were changed after signing", () => {
-        const forged = {
-            ...unbind,
-            contents: { ...unbind.contents, userId: "00maccountemailotheruser0" },
-        };
-        expect((0, account_email_1.verifyEmailUnbind)({
-            signed: forged,
-            userId: "00maccountemailotheruser0",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-    });
-});

package/dist/identity/anchor-document.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/identity/anchor-document.test.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const anchor_document_1 = require("./anchor-document");
-describe("normalizeAnchorList", () => {
-    it("allows http for peers-services and requires https for a page anchor", () => {
-        const list = (0, anchor_document_1.normalizeAnchorList)([
-            { type: "peers-services", url: "http://127.0.0.1:4000/api/v1/keys/abc" },
-            { type: "https", url: "https://example.com/peers.json" },
-        ]);
-        expect(list.map((anchor) => anchor.url)).toEqual([
-            "https://example.com/peers.json",
-            "http://127.0.0.1:4000/api/v1/keys/abc",
-        ]);
-        expect(() => (0, anchor_document_1.normalizeAnchorList)([{ type: "https", url: "http://example.com/peers.json" }])).toThrow(/https/);
-    });
-});

package/dist/identity/anchor-resolution.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/identity/anchor-resolution.test.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-const anchor_document_1 = require("./anchor-document");
-const anchor_resolution_1 = require("./anchor-resolution");
-const userId = (0, index_1.newid)();
-const record = (0, index_1.newKeys)();
-const next = (0, index_1.newKeys)();
-const anchor = {
-    type: "https",
-    url: "https://example.com/.well-known/peers-identity.json",
-};
-function document(keys) {
-    return {
-        version: 1,
-        userId,
-        keys,
-        anchors: [anchor],
-        updatedAt: "2026-10-03T18:00:00.000Z",
-    };
-}
-function confirm(entry) {
-    return { outcome: "document", document: document([entry]), maxAgeSeconds: 30 };
-}
-describe("resolvePresentedKey", () => {
-    const issuedAt = "2026-10-03T18:00:00.000Z";
-    it("confirms a rotation when the key on record co-signed and nobody vetoes", () => {
-        const signed = (0, anchor_document_1.signSuccession)({ purpose: "peers-key-succession", userId, publicKey: next.publicKey, issuedAt }, record.secretKey);
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({
-                    publicKey: next.publicKey,
-                    issuedAt,
-                    reason: "rotation",
-                    authorizedBy: { publicKey: signed.publicKey, signature: signed.signature },
-                }),
-                { outcome: "abstain" },
-            ],
-        });
-        expect(resolution.state).toBe("confirmed-rotation");
-        expect(resolution.successionByRecordKey).toBe(true);
-        expect(resolution.cacheSeconds).toBe(30);
-    });
-    it("treats a listed key without the record key's signature as recovery", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [confirm({ publicKey: next.publicKey, issuedAt, reason: "lost" })],
-        });
-        expect(resolution.state).toBe("confirmed-recovery");
-    });
-    it("vetoes when any anchor omits the presented key", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({ publicKey: next.publicKey, issuedAt }),
-                confirm({ publicKey: record.publicKey, issuedAt }),
-            ],
-        });
-        expect(resolution.state).toBe("vetoed");
-    });
-    it("vetoes a document for another user and a 404", () => {
-        const other = document([{ publicKey: next.publicKey, issuedAt }]);
-        other.userId = (0, index_1.newid)();
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [{ outcome: "document", document: other }, { outcome: "veto" }],
-        });
-        expect(resolution.state).toBe("vetoed");
-    });
-    it("stays pending when every anchor abstains", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [{ outcome: "abstain" }, { outcome: "abstain" }],
-        });
-        expect(resolution.state).toBe("pending");
-    });
-    it("rejects a co-signature that is not the key on record", () => {
-        const imposter = (0, index_1.newKeys)();
-        const signed = (0, anchor_document_1.signSuccession)({ purpose: "peers-key-succession", userId, publicKey: next.publicKey, issuedAt }, imposter.secretKey);
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({
-                    publicKey: next.publicKey,
-                    issuedAt,
-                    authorizedBy: { publicKey: signed.publicKey, signature: signed.signature },
-                }),
-            ],
-        });
-        expect(resolution.state).toBe("confirmed-recovery");
-    });
-});
-describe("resolvePresentedAnchors", () => {
-    const next = [anchor, { type: "https", url: "https://example.com/other.json" }];
-    it("confirms when an anchor publishes the new list and none veto", () => {
-        const decision = (0, anchor_resolution_1.resolvePresentedAnchors)({
-            userId,
-            presented: next,
-            outcomes: [
-                { outcome: "document", document: { ...document([]), anchors: [...next].reverse() } },
-                { outcome: "abstain" },
-            ],
-        });
-        expect(decision).toBe("confirmed");
-    });
-    it("vetoes when an anchor still publishes a different list", () => {
-        const decision = (0, anchor_resolution_1.resolvePresentedAnchors)({
-            userId,
-            presented: next,
-            outcomes: [
-                { outcome: "document", document: document([]) },
-                { outcome: "document", document: { ...document([]), anchors: next } },
-            ],
-        });
-        expect(decision).toBe("vetoed");
-    });
-});

package/dist/identity/key-change.test.d.ts

@@ -1 +0,0 @@
-import "./user-row-change";