@pkcprotocol/pkc-js 0.0.93 → 0.0.94

package/dist/browser/test/test-util.d.ts

@@ -201,9 +201,13 @@ export declare function getAvailablePKCConfigsToTestAgainst(opts?: {
 }): PKCConfigWithName[];
 export declare function createNewIpns(): Promise<{
     signer: import("../signer/index.js").SignerWithPublicKeyAddress;
-    publishToIpns: (content: string) => Promise<void>;
+    publishToIpns: (content: string, opts?: {
+        verifyResolves?: boolean;
+        ttl?: string;
+    }) => Promise<void>;
     publishToIpnsValue: (value: string, opts?: {
         verifyResolves?: boolean;
+        ttl?: string;
     }) => Promise<void>;
     pkc: PKC;
 }>;
@@ -538,15 +542,20 @@ export declare function createDelegatedCommunityIpns(communityOpts?: Partial<Com
     cid: string;
 }>;
 export declare function publishCommunityRecordWithExtraProp(opts?: {
-    includeExtraPropInSignedPropertyNames: boolean;
-    extraProps: Object;
+    includeExtraPropInSignedPropertyNames?: boolean;
+    extraProps?: Object;
+    ttl?: string;
 }): Promise<{
     communityRecord: any;
     ipnsObj: {
         signer: import("../signer/index.js").SignerWithPublicKeyAddress;
-        publishToIpns: (content: string) => Promise<void>;
+        publishToIpns: (content: string, opts?: {
+            verifyResolves?: boolean;
+            ttl?: string;
+        }) => Promise<void>;
         publishToIpnsValue: (value: string, opts?: {
             verifyResolves?: boolean;
+            ttl?: string;
         }) => Promise<void>;
         pkc: PKC;
     };
@@ -877,9 +886,13 @@ export declare function createMockedCommunityIpns(communityOpts: CreateNewLocalC
     communityAddress: string;
     ipnsObj: {
         signer: import("../signer/index.js").SignerWithPublicKeyAddress;
-        publishToIpns: (content: string) => Promise<void>;
+        publishToIpns: (content: string, opts?: {
+            verifyResolves?: boolean;
+            ttl?: string;
+        }) => Promise<void>;
         publishToIpnsValue: (value: string, opts?: {
             verifyResolves?: boolean;
+            ttl?: string;
         }) => Promise<void>;
         pkc: PKC;
     };
@@ -894,6 +907,341 @@ export declare function createStaticCommunityRecordForComment(opts?: {
     commentCid: string;
     communityAddress: string;
 }>;
+export declare function publishStaticCommunityWithPostInPages(): Promise<{
+    communityAddress: string;
+    commentCid: string;
+    communityRecord: {
+        challenges: {
+            [x: string]: unknown;
+            type: string;
+            exclude?: {
+                [x: string]: unknown;
+                community?: {
+                    addresses: string[];
+                    maxCommentCids: number;
+                    postScore?: number | undefined;
+                    replyScore?: number | undefined;
+                    firstCommentTimestamp?: number | undefined;
+                } | undefined;
+                postScore?: number | undefined;
+                replyScore?: number | undefined;
+                postCount?: number | undefined;
+                replyCount?: number | undefined;
+                firstCommentTimestamp?: number | undefined;
+                challenges?: number[] | undefined;
+                role?: string[] | undefined;
+                address?: string[] | undefined;
+                rateLimit?: number | undefined;
+                rateLimitChallengeSuccess?: boolean | undefined;
+                publicationType?: {
+                    [x: string]: unknown;
+                    post?: boolean | undefined;
+                    reply?: boolean | undefined;
+                    vote?: boolean | undefined;
+                    commentEdit?: boolean | undefined;
+                    commentModeration?: boolean | undefined;
+                    communityEdit?: boolean | undefined;
+                } | undefined;
+            }[] | undefined;
+            description?: string | undefined;
+            challenge?: string | undefined;
+            caseInsensitive?: boolean | undefined;
+            pendingApproval?: boolean | undefined;
+            publicOptions?: Record<string, string> | undefined;
+        }[];
+        signature: {
+            type: string;
+            signature: string;
+            publicKey: string;
+            signedPropertyNames: string[];
+        };
+        encryption: {
+            [x: string]: unknown;
+            type: string;
+            publicKey: string;
+        };
+        createdAt: number;
+        updatedAt: number;
+        protocolVersion: string;
+        posts?: {
+            pages: Record<string, {
+                comments: {
+                    comment: {
+                        [x: string]: unknown;
+                        timestamp: number;
+                        signature: {
+                            type: string;
+                            signature: string;
+                            publicKey: string;
+                            signedPropertyNames: string[];
+                        };
+                        protocolVersion: string;
+                        depth: number;
+                        flairs?: {
+                            [x: string]: unknown;
+                            text: string;
+                            backgroundColor?: string | undefined;
+                            textColor?: string | undefined;
+                            expiresAt?: number | undefined;
+                        }[] | undefined;
+                        communityPublicKey?: string | undefined;
+                        communityName?: string | undefined;
+                        link?: string | undefined;
+                        spoiler?: boolean | undefined;
+                        nsfw?: boolean | undefined;
+                        content?: string | undefined;
+                        title?: string | undefined;
+                        linkWidth?: number | undefined;
+                        linkHeight?: number | undefined;
+                        linkHtmlTagName?: string | undefined;
+                        parentCid?: string | undefined;
+                        postCid?: string | undefined;
+                        quotedCids?: string[] | undefined;
+                        crosspost?: import("../publications/comment/schema.js").Crosspost | undefined;
+                        author?: {
+                            [x: string]: unknown;
+                            name?: string | undefined;
+                            previousCommentCid?: string | undefined;
+                            displayName?: string | undefined;
+                            wallets?: Record<string, {
+                                address: string;
+                                timestamp: number;
+                                signature: {
+                                    signature: string;
+                                    type: string;
+                                };
+                            }> | undefined;
+                            avatar?: {
+                                [x: string]: unknown;
+                                chainTicker: string;
+                                address: string;
+                                id: string;
+                                timestamp: number;
+                                signature: {
+                                    signature: string;
+                                    type: string;
+                                };
+                            } | undefined;
+                            flairs?: {
+                                [x: string]: unknown;
+                                text: string;
+                                backgroundColor?: string | undefined;
+                                textColor?: string | undefined;
+                                expiresAt?: number | undefined;
+                            }[] | undefined;
+                        } | undefined;
+                        thumbnailUrl?: string | undefined;
+                        thumbnailUrlWidth?: number | undefined;
+                        thumbnailUrlHeight?: number | undefined;
+                        previousCid?: string | undefined;
+                        pseudonymityMode?: "per-post" | "per-reply" | "per-author" | undefined;
+                    };
+                    commentUpdate: {
+                        [x: string]: unknown;
+                        cid: string;
+                        upvoteCount: number;
+                        downvoteCount: number;
+                        replyCount: number;
+                        updatedAt: number;
+                        signature: {
+                            type: string;
+                            signature: string;
+                            publicKey: string;
+                            signedPropertyNames: string[];
+                        };
+                        protocolVersion: string;
+                        childCount?: number | undefined;
+                        number?: number | undefined;
+                        postNumber?: number | undefined;
+                        edit?: {
+                            [x: string]: unknown;
+                            timestamp: number;
+                            signature: {
+                                type: string;
+                                signature: string;
+                                publicKey: string;
+                                signedPropertyNames: string[];
+                            };
+                            protocolVersion: string;
+                            commentCid: string;
+                            flairs?: {
+                                [x: string]: unknown;
+                                text: string;
+                                backgroundColor?: string | undefined;
+                                textColor?: string | undefined;
+                                expiresAt?: number | undefined;
+                            }[] | undefined;
+                            communityPublicKey?: string | undefined;
+                            communityName?: string | undefined;
+                            spoiler?: boolean | undefined;
+                            nsfw?: boolean | undefined;
+                            reason?: string | undefined;
+                            content?: string | undefined;
+                            deleted?: boolean | undefined;
+                            author?: {
+                                [x: string]: unknown;
+                                name?: string | undefined;
+                                previousCommentCid?: string | undefined;
+                                displayName?: string | undefined;
+                                wallets?: Record<string, {
+                                    address: string;
+                                    timestamp: number;
+                                    signature: {
+                                        signature: string;
+                                        type: string;
+                                    };
+                                }> | undefined;
+                                avatar?: {
+                                    [x: string]: unknown;
+                                    chainTicker: string;
+                                    address: string;
+                                    id: string;
+                                    timestamp: number;
+                                    signature: {
+                                        signature: string;
+                                        type: string;
+                                    };
+                                } | undefined;
+                                flairs?: {
+                                    [x: string]: unknown;
+                                    text: string;
+                                    backgroundColor?: string | undefined;
+                                    textColor?: string | undefined;
+                                    expiresAt?: number | undefined;
+                                }[] | undefined;
+                            } | undefined;
+                        } | undefined;
+                        flairs?: {
+                            [x: string]: unknown;
+                            text: string;
+                            backgroundColor?: string | undefined;
+                            textColor?: string | undefined;
+                            expiresAt?: number | undefined;
+                        }[] | undefined;
+                        spoiler?: boolean | undefined;
+                        nsfw?: boolean | undefined;
+                        pinned?: boolean | undefined;
+                        locked?: boolean | undefined;
+                        archived?: boolean | undefined;
+                        removed?: boolean | undefined;
+                        reason?: string | undefined;
+                        approved?: boolean | undefined;
+                        author?: {
+                            [x: string]: unknown;
+                            community?: {
+                                [x: string]: unknown;
+                                postScore: number;
+                                replyScore: number;
+                                firstCommentTimestamp: number;
+                                lastCommentCid: string;
+                                banExpiresAt?: number | undefined;
+                                flairs?: {
+                                    [x: string]: unknown;
+                                    text: string;
+                                    backgroundColor?: string | undefined;
+                                    textColor?: string | undefined;
+                                    expiresAt?: number | undefined;
+                                }[] | undefined;
+                            } | undefined;
+                        } | undefined;
+                        lastChildCid?: string | undefined;
+                        lastReplyTimestamp?: number | undefined;
+                        replies?: {
+                            pages: Record<string, /*elided*/ any>;
+                            pageCids?: Record<string, string> | undefined;
+                        } | undefined;
+                    };
+                }[];
+                nextCid?: string | undefined;
+            }>;
+            pageCids?: Record<string, string> | undefined;
+        } | undefined;
+        modQueue?: {
+            pageCids: Record<string, string>;
+        } | undefined;
+        name?: string | undefined;
+        anchor?: {
+            publicKey: string;
+        } | undefined;
+        pubsubTopic?: string | undefined;
+        statsCid?: string | undefined;
+        postUpdates?: Record<string, string> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        roles?: Record<string, {
+            [x: string]: unknown;
+            role: string;
+        }> | undefined;
+        rules?: string[] | undefined;
+        lastPostCid?: string | undefined;
+        lastCommentCid?: string | undefined;
+        features?: {
+            [x: string]: unknown;
+            noVideos?: boolean | undefined;
+            noSpoilers?: boolean | undefined;
+            noImages?: boolean | undefined;
+            noVideoReplies?: boolean | undefined;
+            noSpoilerReplies?: boolean | undefined;
+            noImageReplies?: boolean | undefined;
+            noReplyLinks?: boolean | undefined;
+            noPolls?: boolean | undefined;
+            noCrossposts?: boolean | undefined;
+            maxCrosspostDepth?: number | undefined;
+            noNestedReplies?: boolean | undefined;
+            safeForWork?: boolean | undefined;
+            authorFlairs?: boolean | undefined;
+            requireAuthorFlairs?: boolean | undefined;
+            postFlairs?: boolean | undefined;
+            requirePostFlairs?: boolean | undefined;
+            noMarkdownImages?: boolean | undefined;
+            noMarkdownVideos?: boolean | undefined;
+            noMarkdownAudio?: boolean | undefined;
+            noAudio?: boolean | undefined;
+            noAudioReplies?: boolean | undefined;
+            markdownImageReplies?: boolean | undefined;
+            markdownVideoReplies?: boolean | undefined;
+            noPostUpvotes?: boolean | undefined;
+            noReplyUpvotes?: boolean | undefined;
+            noPostDownvotes?: boolean | undefined;
+            noReplyDownvotes?: boolean | undefined;
+            noUpvotes?: boolean | undefined;
+            noDownvotes?: boolean | undefined;
+            requirePostLink?: boolean | undefined;
+            requirePostLinkIsMedia?: boolean | undefined;
+            requireReplyLink?: boolean | undefined;
+            requireReplyLinkIsMedia?: boolean | undefined;
+            pseudonymityMode?: "per-post" | "per-reply" | "per-author" | undefined;
+        } | undefined;
+        suggested?: {
+            [x: string]: unknown;
+            primaryColor?: string | undefined;
+            secondaryColor?: string | undefined;
+            avatarUrl?: string | undefined;
+            bannerUrl?: string | undefined;
+            backgroundUrl?: string | undefined;
+            language?: string | undefined;
+        } | undefined;
+        flairs?: Record<string, {
+            [x: string]: unknown;
+            text: string;
+            backgroundColor?: string | undefined;
+            textColor?: string | undefined;
+            expiresAt?: number | undefined;
+        }[]> | undefined;
+    };
+    ipnsObj: {
+        signer: import("../signer/index.js").SignerWithPublicKeyAddress;
+        publishToIpns: (content: string, opts?: {
+            verifyResolves?: boolean;
+            ttl?: string;
+        }) => Promise<void>;
+        publishToIpnsValue: (value: string, opts?: {
+            verifyResolves?: boolean;
+            ttl?: string;
+        }) => Promise<void>;
+        pkc: PKC;
+    };
+}>;
 export declare function jsonifyCommunityAndRemoveInternalProps(community: RemoteCommunity): {
     [x: string]: any;
 };

package/dist/browser/test/test-util.js

@@ -11,7 +11,7 @@ import { clone, flat, isEmpty, keys, mergeDeep, omit, pick } from "remeda";
 import { LocalCommunity } from "../runtime/browser/community/local-community.js";
 import { findUpdatingComment, findUpdatingCommunity } from "../pkc/tracked-instance-registry-util.js";
 import pTimeout from "p-timeout";
-import { signComment, _signJson, signCommentEdit, cleanUpBeforePublishing, _signPubsubMsg, signChallengeVerification, signCommunity } from "../signer/signatures.js";
+import { signComment, _signJson, signCommentEdit, cleanUpBeforePublishing, _signPubsubMsg, signChallengeVerification, signCommentUpdate, signCommunity } from "../signer/signatures.js";
 import { findCommentInHierarchicalPageIpfsRecursively, findCommentInPageInstance, mapPageIpfsCommentToPageJsonComment, TIMEFRAMES_TO_SECONDS } from "../pages/util.js";
 import { importSignerIntoKuboNode } from "../runtime/browser/util.js";
 import { getIpfsKeyFromPrivateKey, getPKCAddressFromPublicKeySync } from "../signer/util.js";
@@ -1199,6 +1199,11 @@ export async function createNewIpns() {
     // ONLY controls the helper's own post-publish name.resolve() sanity check (which syncs Kubo's
     // cache for RPC tests) — it does NOT change what name.publish does. Set it false when
     // publishing a hop whose target isn't resolvable yet, so that resolve check doesn't fail.
+    // `ttl` (kubo duration string, e.g. "10s") overrides kubo's default record ttl, which is 5
+    // MINUTES on kubo 0.43, not the 60s a LocalCommunity publishes (publishInterval * 3). The
+    // ttl bounds how long the libp2p-js resolver may serve a name from its routing-layer cache
+    // without revalidating (issue #301/#307), so any test that must observe a cache expiry
+    // inside its own timeout has to shorten it here instead of waiting out kubo's default.
     const publishToIpnsValue = async (value, opts) => {
         const verifyResolves = opts?.verifyResolves ?? true;
         // Wrapped in retry because Kubo can transiently ETIMEDOUT in CI
@@ -1212,7 +1217,8 @@ export async function createNewIpns() {
                 try {
                     await ipfsClient._client.name.publish(value, {
                         key: signer.address,
-                        allowOffline: true
+                        allowOffline: true,
+                        ...(opts?.ttl ? { ttl: opts.ttl } : {})
                     });
                     resolve();
                 }
@@ -1253,9 +1259,9 @@ export async function createNewIpns() {
             });
         });
     };
-    const publishToIpns = async (content) => {
+    const publishToIpns = async (content, opts) => {
         const cid = await addStringToIpfs(content);
-        await publishToIpnsValue(cid);
+        await publishToIpnsValue(cid, opts);
     };
     return {
         signer,
@@ -1344,7 +1350,7 @@ export async function publishCommunityRecordWithExtraProp(opts) {
     if (opts?.includeExtraPropInSignedPropertyNames)
         signedPropertyNames.push("extraProp");
     communityRecord.signature = await _signJson(signedPropertyNames, communityRecord, ipnsObj.signer, Logger("pkc-js:test-util:publishCommunityRecordWithExtraProp"));
-    await ipnsObj.publishToIpns(JSON.stringify(communityRecord));
+    await ipnsObj.publishToIpns(JSON.stringify(communityRecord), opts?.ttl ? { ttl: opts.ttl } : undefined);
     return { communityRecord, ipnsObj };
 }
 // getTemplateCommunityRecord clones a live community's record, so its encryption block belongs to
@@ -1434,6 +1440,83 @@ export async function createStaticCommunityRecordForComment(opts) {
             await commentPKC.destroy();
     }
 }
+// Publish a STATIC community under a fresh IPNS key whose preloaded posts page embeds one post
+// (author-signed CommentIpfs + a CommentUpdate signed by the community key) and whose postUpdates
+// points at a real UnixFS folder on the test Kubo holding that post's CommentUpdate at
+// <folderCid>/<postCid>/update. The record is published exactly once and nothing ever publishes
+// to this key again, so an update loop watching it is deterministic: no gossip arrivals from
+// concurrent suites, no new records — the literal "community is not publishing new community
+// records" scenario the state-order suites pin. Built for those suites (PR #311 flake class):
+// the shared live communities (signers[0]) receive publishes from every concurrently-running
+// suite, and since the update loop became arrival-driven each of those publishes starts a fetch
+// cycle at a random moment, racing any exact state-sequence assertion.
+export async function publishStaticCommunityWithPostInPages() {
+    const ipnsObj = await createNewIpns();
+    const communityAddress = ipnsObj.signer.address;
+    const commentPKC = await mockPKCNoDataPathWithOnlyKuboClient();
+    try {
+        const commentToPublish = await commentPKC.createComment({
+            signer: await commentPKC.createSigner(),
+            communityAddress,
+            title: `Static post in pages - ${Date.now()}`,
+            content: `Static content - ${Date.now()}`
+        });
+        if (!commentToPublish.raw.pubsubMessageToPublish) {
+            // Directly set _community from in-memory data so signing doesn't fetch the community
+            // record over the network (same trick as createStaticCommunityRecordForComment).
+            commentToPublish["_community"] = {
+                address: communityAddress,
+                publicKey: communityAddress,
+                encryption: encryptionForSigner(ipnsObj.signer),
+                pubsubTopic: communityAddress
+            };
+            await commentToPublish._signPublicationWithCommunityFields();
+        }
+        // The SAME serialization is added to IPFS and embedded in the page, so the cid the page
+        // verifier recomputes from the embedded comment matches commentUpdate.cid.
+        const commentIpfs = { ...commentToPublish.raw.pubsubMessageToPublish, depth: 0 };
+        if (!commentIpfs.protocolVersion)
+            throw Error("The comment to embed in the static community must carry a protocolVersion");
+        const commentIpfsJson = JSON.stringify(commentIpfs);
+        const commentCid = await addStringToIpfs(commentIpfsJson);
+        const commentUpdateWithoutSignature = {
+            cid: commentCid,
+            upvoteCount: 0,
+            downvoteCount: 0,
+            replyCount: 0,
+            updatedAt: timestamp(),
+            protocolVersion: commentIpfs.protocolVersion
+        };
+        const commentUpdate = {
+            ...commentUpdateWithoutSignature,
+            signature: await signCommentUpdate({ update: commentUpdateWithoutSignature, signer: ipnsObj.signer })
+        };
+        // postUpdates folder on the test Kubo: <folderCid>/<postCid>/update.
+        const kuboClient = ipnsObj.pkc._clientsManager.getDefaultKuboRpcClient()._client;
+        let folderCid;
+        for await (const addedEntry of kuboClient.addAll([{ path: `${commentCid}/update`, content: JSON.stringify(commentUpdate) }], {
+            wrapWithDirectory: true
+        }))
+            if (addedEntry.path === "")
+                folderCid = addedEntry.cid.toString();
+        if (!folderCid)
+            throw Error("Failed to derive the postUpdates folder cid from the wrapped kubo add");
+        const communityRecord = {
+            ...(await getTemplateCommunityRecord(ipnsObj.pkc)),
+            posts: { pages: { hot: { comments: [{ comment: JSON.parse(commentIpfsJson), commentUpdate }] } } },
+            postUpdates: { "86400": folderCid },
+            pubsubTopic: communityAddress,
+            encryption: encryptionForSigner(ipnsObj.signer),
+            updatedAt: timestamp()
+        };
+        communityRecord.signature = await signCommunity({ community: communityRecord, signer: ipnsObj.signer });
+        await ipnsObj.publishToIpns(JSON.stringify(communityRecord));
+        return { communityAddress, commentCid, communityRecord, ipnsObj };
+    }
+    finally {
+        await commentPKC.destroy();
+    }
+}
 function _stripNameResolvedFromPages(pagesContainer) {
     if (!pagesContainer?.pages)
         return;