@pkcprotocol/pkc-js 0.0.26 → 0.0.28

package/dist/browser/runtime/node/community/challenges/index.js

@@ -10,9 +10,9 @@ import * as remeda from "remeda";
 import { ChallengeFileFactorySchema, ChallengeFileSchema, CommunityChallengeSettingSchema } from "../../../../community/schema.js";
 import { PKCError } from "../../../../pkc-error.js";
 import { pathToFileURL } from "node:url";
-const resolveChallengeFactoryByName = (name, pkc) => {
+const resolveChallengeFactoryByName = ({ name, pkc }) => {
     // User-defined shadows built-ins
-    return pkc?.settings?.challenges?.[name] ?? pkcJsChallenges[name];
+    return { factory: pkc?.settings?.challenges?.[name] ?? pkcJsChallenges[name] };
 };
 const pkcJsChallenges = {
     "text-math": textMath,
@@ -22,190 +22,412 @@ const pkcJsChallenges = {
     question: question,
     "publication-match": publicationMatch
 };
-const validateChallengeFileFactory = (challengeFileFactory, challengeIndex, community) => {
+const validateChallengeFileFactory = ({ challengeFileFactory, challengeIndex, community }) => {
     const communityChallengeSettings = community?.settings?.challenges?.[challengeIndex];
     if (typeof challengeFileFactory !== "function") {
         throw Error(`invalid challenge file factory export from community challenge '${communityChallengeSettings?.name || communityChallengeSettings?.path}' (challenge #${challengeIndex + 1})`);
     }
+    return { ok: true };
 };
-const validateChallengeFile = (challengeFile, challengeIndex, community) => {
+const validateChallengeFile = ({ challengeFile, challengeIndex, community }) => {
     const communityChallengeSettings = community.settings?.challenges?.[challengeIndex];
     if (typeof challengeFile?.getChallenge !== "function") {
         throw Error(`invalid challenge file from community challenge '${communityChallengeSettings?.name || communityChallengeSettings?.path}' (challenge #${challengeIndex + 1})`);
     }
+    return { ok: true };
 };
-const validateChallengeResult = (challengeResult, challengeIndex, community) => {
+const validateChallengeResult = ({ challengeResult, challengeIndex, community }) => {
     const communityChallengeSettings = community.settings?.challenges?.[challengeIndex];
     const error = `invalid challenge result from community challenge '${communityChallengeSettings?.name || communityChallengeSettings?.path}' (challenge #${challengeIndex + 1})`;
     if (typeof challengeResult?.success !== "boolean") {
         throw Error(error);
     }
+    return { ok: true };
 };
-const validateChallengeOrChallengeResult = (challengeOrChallengeResult, challengeIndex, community) => {
+const validateChallengeOrChallengeResult = ({ challengeOrChallengeResult, challengeIndex, community }) => {
     if ("success" in challengeOrChallengeResult) {
-        validateChallengeResult(challengeOrChallengeResult, challengeIndex, community);
+        validateChallengeResult({ challengeResult: challengeOrChallengeResult, challengeIndex, community });
     }
     else if (typeof challengeOrChallengeResult?.["challenge"] !== "string" ||
         typeof challengeOrChallengeResult?.["type"] !== "string" ||
         typeof challengeOrChallengeResult?.["verify"] !== "function") {
         throw Error("The challenge does not contain the correct {challenge, type, verify}");
     }
+    return { ok: true };
 };
-const getPendingChallengesOrChallengeVerification = async (challengeRequestMessage, community) => {
+// load and validate a challenge factory + ChallengeFile for one challenge index
+const loadChallengeFile = async ({ communityChallengeSettings, challengeIndex, community }) => {
+    if (!communityChallengeSettings.path &&
+        !resolveChallengeFactoryByName({ name: communityChallengeSettings.name, pkc: community._pkc }).factory)
+        throw Error("You have to provide either path or a stored pkc-js challenge");
+    let ChallengeFileFactory;
+    try {
+        ChallengeFileFactory = ChallengeFileFactorySchema.parse(communityChallengeSettings.path
+            ? (await import(pathToFileURL(communityChallengeSettings.path).href)).default
+            : resolveChallengeFactoryByName({ name: communityChallengeSettings.name, pkc: community._pkc }).factory);
+        validateChallengeFileFactory({ challengeFileFactory: ChallengeFileFactory, challengeIndex, community });
+    }
+    catch (e) {
+        throw new PKCError("ERR_FAILED_TO_IMPORT_CHALLENGE_FILE_FACTORY", {
+            path: communityChallengeSettings.path,
+            communityChallengeSettings,
+            error: e,
+            challengeIndex
+        });
+    }
+    const challengeFile = ChallengeFileFactory({ challengeSettings: communityChallengeSettings });
+    validateChallengeFile({ challengeFile, challengeIndex, community });
+    return { challengeFile };
+};
+// invoke getChallenge() with shared error handling and result validation
+const callGetChallenge = async ({ challengeFile, communityChallengeSettings, challengeRequestMessage, challengeIndex, community }) => {
+    let challengeOrChallengeResult;
+    try {
+        challengeOrChallengeResult = await challengeFile.getChallenge({
+            challengeSettings: communityChallengeSettings,
+            challengeRequestMessage,
+            challengeIndex,
+            community
+        });
+        validateChallengeOrChallengeResult({ challengeOrChallengeResult, challengeIndex, community });
+    }
+    catch (e) {
+        throw new PKCError("ERR_INVALID_RESULT_FROM_GET_CHALLENGE_FUNCTION", {
+            communityChallengeSettings,
+            challengeName: communityChallengeSettings.name || communityChallengeSettings.path,
+            challengeRequestMessage,
+            challengeIndex: challengeIndex + 1,
+            error: e
+        });
+    }
+    return { challengeOrChallengeResult };
+};
+const evaluatePhase2Exclusion = ({ i, communityChallenges, decided, results }) => {
+    const communityChallenge = communityChallenges[i];
+    if (!communityChallenge.exclude?.length)
+        return { decision: "ready" };
+    let allRulesEvaluable = true;
+    let anyDeferRule = false;
+    for (const item of communityChallenge.exclude) {
+        if (!item.challenges?.length)
+            continue;
+        let allDecided = true;
+        for (const j of item.challenges) {
+            if (!decided[j]) {
+                allDecided = false;
+                break;
+            }
+        }
+        if (!allDecided) {
+            allRulesEvaluable = false;
+            continue;
+        }
+        let allSuccessOrPending = true;
+        let anyPending = false;
+        const pendingDeps = [];
+        for (const j of item.challenges) {
+            const r = results[j];
+            if (r === undefined) {
+                allSuccessOrPending = false;
+                break;
+            }
+            if ("success" in r) {
+                if (r.success !== true) {
+                    allSuccessOrPending = false;
+                    break;
+                }
+            }
+            else {
+                anyPending = true;
+                pendingDeps.push(j);
+            }
+        }
+        if (!allSuccessOrPending)
+            continue;
+        if (!anyPending)
+            return { decision: "exclude" }; // all deps succeeded → definitively exclude i
+        // Tentative match (some pending). Defer only if no pending dep references i back —
+        // otherwise calling i could affect the pending dep's exclusion, so we should call.
+        let allOneWay = true;
+        for (const j of pendingDeps) {
+            const cj = communityChallenges[j];
+            const referencesBack = cj.exclude?.some((it) => it.challenges?.includes(i));
+            if (referencesBack) {
+                allOneWay = false;
+                break;
+            }
+        }
+        if (allOneWay)
+            anyDeferRule = true;
+    }
+    if (anyDeferRule)
+        return { decision: "defer" };
+    return { decision: allRulesEvaluable ? "ready" : "skip" };
+};
+const getPendingChallengesOrChallengeVerification = async ({ challengeRequestMessage, community }) => {
     // if community has no challenges, no need to send a challenge
     if (!Array.isArray(community.settings?.challenges))
         return {
             challengeSuccess: true,
             pendingApprovalSuccess: false
         };
-    const challengeOrChallengeResults = [];
-    // interate over all challenges of the community, can be more than 1
-    for (const i in community.settings.challenges) {
-        const challengeIndex = Number(i);
-        const communityChallengeSettings = community.settings.challenges[challengeIndex];
-        if (!communityChallengeSettings.path && !resolveChallengeFactoryByName(communityChallengeSettings.name, community._pkc))
-            throw Error("You have to provide either path or a stored pkc-js challenge");
-        // if the challenge is an external file, fetch it and override the communityChallengeSettings values
-        let ChallengeFileFactory;
-        try {
-            ChallengeFileFactory = ChallengeFileFactorySchema.parse(communityChallengeSettings.path
-                ? (await import(pathToFileURL(communityChallengeSettings.path).href)).default
-                : resolveChallengeFactoryByName(communityChallengeSettings.name, community._pkc));
-            validateChallengeFileFactory(ChallengeFileFactory, challengeIndex, community);
+    const challengeCount = community.settings.challenges.length;
+    const results = new Array(challengeCount);
+    const decided = new Array(challengeCount).fill(false);
+    // Phase 0: load CommunityChallenge records for every index in parallel.
+    const communityChallenges = await Promise.all(community.settings.challenges.map(async (s) => (await getCommunityChallengeFromCommunityChallengeSettings({
+        communityChallengeSettings: s,
+        pkc: community._pkc
+    })).communityChallenge));
+    // Phase 0b: load challenge files (factories) for every index in parallel — needed for getChallenge calls
+    // in phases 2/3. Loading them upfront avoids re-importing during the dependency-ordered loop.
+    const challengeFiles = await Promise.all(community.settings.challenges.map(async (s, i) => (await loadChallengeFile({ communityChallengeSettings: s, challengeIndex: i, community })).challengeFile));
+    // Phase 1: request-only excludes (parallel). Indexes excluded here never reach getChallenge.
+    await Promise.all(communityChallenges.map(async (communityChallenge, i) => {
+        if (shouldExcludePublication(communityChallenge, challengeRequestMessage, community)) {
+            decided[i] = true;
+            return;
         }
-        catch (e) {
-            throw new PKCError("ERR_FAILED_TO_IMPORT_CHALLENGE_FILE_FACTORY", {
-                path: communityChallengeSettings.path,
-                communityChallengeSettings,
-                error: e,
-                challengeIndex
-            });
+        if (await shouldExcludeChallengeCommentCids(communityChallenge, challengeRequestMessage, community._pkc)) {
+            decided[i] = true;
         }
-        const challengeFile = ChallengeFileFactory({ challengeSettings: communityChallengeSettings });
-        validateChallengeFile(challengeFile, challengeIndex, community);
-        let challengeOrChallengeResult;
-        try {
-            // the getChallenge function could throw
-            challengeOrChallengeResult = await challengeFile.getChallenge({
-                challengeSettings: communityChallengeSettings,
-                challengeRequestMessage,
-                challengeIndex,
-                community
-            });
-            validateChallengeOrChallengeResult(challengeOrChallengeResult, challengeIndex, community);
+    }));
+    // Phase 2 + 3: dependency-ordered resolution with incremental cycle-break.
+    // `deferred[i] = true` means index i was decided but its result is not yet known — it will be
+    // resolved at verify time once pending challenges produce verify outcomes.
+    const deferred = new Array(challengeCount).fill(false);
+    while (true) {
+        let progress = false;
+        for (let i = 0; i < challengeCount; i++) {
+            if (decided[i])
+                continue;
+            const { decision } = evaluatePhase2Exclusion({ i, communityChallenges, decided, results });
+            if (decision === "skip")
+                continue;
+            if (decision === "exclude") {
+                decided[i] = true;
+            }
+            else if (decision === "defer") {
+                decided[i] = true;
+                deferred[i] = true;
+            }
+            else {
+                results[i] = (await callGetChallenge({
+                    challengeFile: challengeFiles[i],
+                    communityChallengeSettings: community.settings.challenges[i],
+                    challengeRequestMessage,
+                    challengeIndex: i,
+                    community
+                })).challengeOrChallengeResult;
+                decided[i] = true;
+            }
+            progress = true;
         }
-        catch (e) {
-            throw new PKCError("ERR_INVALID_RESULT_FROM_GET_CHALLENGE_FUNCTION", {
-                communityChallengeSettings,
-                challengeName: communityChallengeSettings.name || communityChallengeSettings.path,
-                challengeRequestMessage,
-                challengeIndex: challengeIndex + 1,
-                error: e
-            });
+        if (progress)
+            continue;
+        // Stalled. Decide between phase 3 (cycle-break) and phase 4 (defer remaining).
+        const hasPending = results.some((r) => r !== undefined && !("success" in r));
+        const firstUndecided = decided.findIndex((d) => !d);
+        if (firstUndecided === -1)
+            break;
+        if (hasPending) {
+            // Defer all remaining undecided to verify time.
+            for (let i = 0; i < challengeCount; i++) {
+                if (!decided[i]) {
+                    decided[i] = true;
+                    deferred[i] = true;
+                }
+            }
+            break;
         }
-        challengeOrChallengeResults.push(challengeOrChallengeResult);
+        // Phase 3: cycle-break by calling getChallenge for the lowest-index undecided challenge.
+        results[firstUndecided] = (await callGetChallenge({
+            challengeFile: challengeFiles[firstUndecided],
+            communityChallengeSettings: community.settings.challenges[firstUndecided],
+            challengeRequestMessage,
+            challengeIndex: firstUndecided,
+            community
+        })).challengeOrChallengeResult;
+        decided[firstUndecided] = true;
+    }
+    // Phase 4: collect deferred-bucket entries.
+    const deferredChallenges = [];
+    for (let i = 0; i < challengeCount; i++) {
+        if (deferred[i])
+            deferredChallenges.push({ index: i, communityChallenge: communityChallenges[i] });
     }
-    // check failures and errors
+    // Phase 5: classification — tally failures, pending, pendingApproval over the populated result
+    // array. Mirrors the original two-pass orchestrator: shouldExcludeChallengeSuccess is applied
+    // uniformly to every populated slot before classifying its result.
     let challengeFailureCount = 0;
     let pendingChallenges = [];
     const challengeErrors = {};
     let pendingApprovalSuccess = false;
-    for (const i in challengeOrChallengeResults) {
-        const challengeIndex = Number(i);
-        const challengeOrChallengeResult = challengeOrChallengeResults[challengeIndex];
-        const communityChallengeSettings = community.settings.challenges[challengeIndex];
-        const communityChallenge = await getCommunityChallengeFromCommunityChallengeSettings(communityChallengeSettings, community._pkc);
-        // exclude author from challenge based on the community minimum karma settings
-        if (shouldExcludePublication(communityChallenge, challengeRequestMessage, community)) {
+    for (let i = 0; i < challengeCount; i++) {
+        const r = results[i];
+        if (r === undefined)
+            continue; // excluded earlier (phase 1 or phase 2)
+        if (shouldExcludeChallengeSuccess(communityChallenges[i], i, results))
             continue;
-        }
-        if (await shouldExcludeChallengeCommentCids(communityChallenge, challengeRequestMessage, community._pkc)) {
-            continue;
-        }
-        // exclude based on other challenges successes
-        if (shouldExcludeChallengeSuccess(communityChallenge, challengeIndex, challengeOrChallengeResults)) {
-            continue;
-        }
-        if ("success" in challengeOrChallengeResult && challengeOrChallengeResult.success === false) {
+        if ("success" in r && r.success === false) {
             challengeFailureCount++;
-            challengeErrors[challengeIndex] = challengeOrChallengeResult.error;
+            challengeErrors[i] = r.error;
         }
-        else if ("success" in challengeOrChallengeResult && challengeOrChallengeResult.success === true) {
-            if (community.challenges?.[challengeIndex]?.pendingApproval) {
+        else if ("success" in r && r.success === true) {
+            if (communityChallenges[i].pendingApproval)
                 pendingApprovalSuccess = true;
-            }
         }
         else {
-            // index is needed to exlude based on other challenge success in getChallengeVerification
-            pendingChallenges.push({ ...challengeOrChallengeResult, index: challengeIndex });
+            pendingChallenges.push({ ...r, index: i });
         }
     }
-    // challenge success can be undefined if there are pending challenges
     let challengeSuccess = undefined;
-    // if there are any failures, success is false and pending challenges are ignored
+    // any failure short-circuits pending and deferred
     if (challengeFailureCount > 0) {
         challengeSuccess = false;
         pendingChallenges = [];
     }
-    // if there are no pending challenges and no failures, success is true
     if (pendingChallenges.length === 0 && challengeFailureCount === 0) {
         challengeSuccess = true;
     }
-    // create return value
-    if (challengeSuccess === true) {
+    if (challengeSuccess === true)
         return { challengeSuccess, pendingApprovalSuccess };
-    }
-    else if (challengeSuccess === false) {
-        return {
-            challengeSuccess,
-            challengeErrors
-        };
-    }
-    else {
-        return { pendingChallenges, pendingApprovalSuccess };
-    }
+    if (challengeSuccess === false)
+        return { challengeSuccess, challengeErrors };
+    return {
+        pendingChallenges,
+        pendingApprovalSuccess,
+        deferredChallenges: deferredChallenges.length > 0 ? deferredChallenges : undefined,
+        partialResults: results,
+        communityChallenges
+    };
 };
-const getChallengeVerificationFromChallengeAnswers = async (pendingChallenges, challengeAnswers, community) => {
+const getChallengeVerificationFromChallengeAnswers = async ({ pendingChallenges, challengeAnswers, community, challengeRequestMessage, deferredChallenges, partialResults, communityChallenges }) => {
+    if (!Array.isArray(community.settings?.challenges))
+        throw Error("community.settings?.challenges is not defined");
+    const challengeCount = community.settings.challenges.length;
+    // Run verify() for every pending challenge in parallel.
     const verifyChallengePromises = [];
     for (const i in pendingChallenges) {
         verifyChallengePromises.push(Promise.resolve(pendingChallenges[i].verify(challengeAnswers[i])));
     }
     const challengeResultsWithPendingIndexes = await Promise.all(verifyChallengePromises);
-    // validate results
     for (const i in challengeResultsWithPendingIndexes) {
-        const challengeResult = challengeResultsWithPendingIndexes[Number(i)];
-        validateChallengeResult(challengeResult, pendingChallenges[Number(i)].index, community);
+        validateChallengeResult({
+            challengeResult: challengeResultsWithPendingIndexes[Number(i)],
+            challengeIndex: pendingChallenges[Number(i)].index,
+            community
+        });
     }
-    // when filtering only pending challenges, the original indexes get lost so restore them
-    const challengeResults = [];
-    const challengeResultToPendingChallenge = [];
+    // Hydrate the result array from the persisted partial state. The pre-verify orchestrator marks
+    // excluded slots as undefined, resolved-immediate slots with their {success} object, and the
+    // pending slots with their {challenge, verify, type} object — replace those pending slots with
+    // the verify result here.
+    const results = partialResults ? partialResults.slice() : new Array(challengeCount);
     for (const i in challengeResultsWithPendingIndexes) {
-        challengeResults[pendingChallenges[i].index] = challengeResultsWithPendingIndexes[i];
-        challengeResultToPendingChallenge[pendingChallenges[i].index] = pendingChallenges[i];
+        results[pendingChallenges[i].index] = challengeResultsWithPendingIndexes[i];
+    }
+    // Lazily reload CommunityChallenge records if the caller didn't pass them through (back-compat).
+    const loadedCommunityChallenges = communityChallenges ??
+        (await Promise.all(community.settings.challenges.map(async (s) => (await getCommunityChallengeFromCommunityChallengeSettings({
+            communityChallengeSettings: s,
+            pkc: community._pkc
+        })).communityChallenge)));
+    // Resolve the deferred bucket. By this point all originally-pending challenges have a verify
+    // result, so the dependency-ordered fixpoint can make progress for any deferred challenge whose
+    // exclude.challenges deps are all decided.
+    const deferred = deferredChallenges ?? [];
+    if (deferred.length > 0) {
+        if (!challengeRequestMessage)
+            throw Error("getChallengeVerificationFromChallengeAnswers requires challengeRequestMessage when deferredChallenges is non-empty");
+        const decided = new Array(challengeCount).fill(true);
+        for (const d of deferred)
+            decided[d.index] = false;
+        // Reload challenge files lazily — only for deferred indexes whose getChallenge actually fires.
+        const challengeFilesByIndex = {};
+        const ensureChallengeFile = async (i) => {
+            if (!challengeFilesByIndex[i]) {
+                challengeFilesByIndex[i] = (await loadChallengeFile({
+                    communityChallengeSettings: community.settings.challenges[i],
+                    challengeIndex: i,
+                    community
+                })).challengeFile;
+            }
+            return challengeFilesByIndex[i];
+        };
+        while (true) {
+            let progress = false;
+            for (const d of deferred) {
+                const i = d.index;
+                if (decided[i])
+                    continue;
+                const { decision } = evaluatePhase2Exclusion({
+                    i,
+                    communityChallenges: loadedCommunityChallenges,
+                    decided,
+                    results
+                });
+                if (decision === "skip")
+                    continue;
+                if (decision === "exclude" || decision === "defer") {
+                    // No more pending challenges at verify time, so "defer" collapses to "exclude":
+                    // a tentatively-matching rule has all-decided deps and ≥1 was pending — but
+                    // those have verify results now, so the rule no longer matches via pending. Treat
+                    // as exclude to be safe: the slot stays undefined, which is the same as today's
+                    // "filtered out" semantics.
+                    decided[i] = true;
+                }
+                else {
+                    const file = await ensureChallengeFile(i);
+                    results[i] = (await callGetChallenge({
+                        challengeFile: file,
+                        communityChallengeSettings: community.settings.challenges[i],
+                        challengeRequestMessage,
+                        challengeIndex: i,
+                        community
+                    })).challengeOrChallengeResult;
+                    decided[i] = true;
+                }
+                progress = true;
+            }
+            if (progress)
+                continue;
+            const firstUndecided = decided.findIndex((d) => !d);
+            if (firstUndecided === -1)
+                break;
+            // Cycle-break: lowest-index undecided deferred index.
+            const file = await ensureChallengeFile(firstUndecided);
+            results[firstUndecided] = (await callGetChallenge({
+                challengeFile: file,
+                communityChallengeSettings: community.settings.challenges[firstUndecided],
+                challengeRequestMessage,
+                challengeIndex: firstUndecided,
+                community
+            })).challengeOrChallengeResult;
+            decided[firstUndecided] = true;
+        }
     }
+    // Classification over the final result array.
     let challengeFailureCount = 0;
     const challengeErrors = {};
     let pendingApprovalSuccess = false;
-    for (let i in challengeResults) {
-        const challengeIndex = Number(i);
-        if (!community.settings?.challenges?.[challengeIndex])
-            throw Error("community.settings.challenges[challengeIndex] does not exist");
-        const challengeResult = challengeResults[challengeIndex];
-        // the challenge results that were filtered out were already successful
-        if (challengeResult === undefined) {
-            continue;
-        }
-        // exclude based on other challenges successes
-        if (shouldExcludeChallengeSuccess(community.settings.challenges[challengeIndex], challengeIndex, challengeResults)) {
+    for (let i = 0; i < challengeCount; i++) {
+        const r = results[i];
+        if (r === undefined)
             continue;
-        }
-        if (challengeResult.success === false) {
+        if ("success" in r && r.success === false) {
+            if (shouldExcludeChallengeSuccess(loadedCommunityChallenges[i], i, results))
+                continue;
             challengeFailureCount++;
-            challengeErrors[challengeIndex] = challengeResult.error;
+            challengeErrors[i] = r.error;
         }
-        else if (challengeResult.success === true && community.settings.challenges[challengeIndex]?.pendingApproval) {
-            pendingApprovalSuccess = true;
+        else if ("success" in r && r.success === true) {
+            if (shouldExcludeChallengeSuccess(loadedCommunityChallenges[i], i, results))
+                continue;
+            if (loadedCommunityChallenges[i].pendingApproval)
+                pendingApprovalSuccess = true;
         }
+        // Any pending shape left at this point would be unexpected; ignore.
     }
     if (challengeFailureCount > 0) {
         return {
@@ -218,7 +440,7 @@ const getChallengeVerificationFromChallengeAnswers = async (pendingChallenges, c
         pendingApprovalSuccess
     };
 };
-const getChallengeVerification = async (challengeRequestMessage, community, getChallengeAnswers) => {
+const getChallengeVerification = async ({ challengeRequestMessage, community, getChallengeAnswers }) => {
     if (!challengeRequestMessage) {
         throw Error(`getChallengeVerification invalid challengeRequestMessage argument '${challengeRequestMessage}'`);
     }
@@ -230,13 +452,21 @@ const getChallengeVerification = async (challengeRequestMessage, community, getC
     }
     if (!Array.isArray(community.settings?.challenges))
         throw Error("community.settings?.challenges is not defined");
-    const res = await getPendingChallengesOrChallengeVerification(challengeRequestMessage, community);
+    const res = await getPendingChallengesOrChallengeVerification({ challengeRequestMessage, community });
     let pendingApprovalSuccess = "pendingApprovalSuccess" in res ? res.pendingApprovalSuccess : false;
     let challengeVerification;
     // was able to verify without asking author for challenges
     if ("pendingChallenges" in res) {
         const challengeAnswers = await getChallengeAnswers(res.pendingChallenges.map((challenge) => remeda.omit(challenge, ["index", "verify"])));
-        const verificationFromPending = await getChallengeVerificationFromChallengeAnswers(res.pendingChallenges, challengeAnswers, community);
+        const verificationFromPending = await getChallengeVerificationFromChallengeAnswers({
+            pendingChallenges: res.pendingChallenges,
+            challengeAnswers,
+            community,
+            challengeRequestMessage,
+            deferredChallenges: res.deferredChallenges,
+            partialResults: res.partialResults,
+            communityChallenges: res.communityChallenges
+        });
         if ("pendingApprovalSuccess" in verificationFromPending) {
             pendingApprovalSuccess = pendingApprovalSuccess || verificationFromPending.pendingApprovalSuccess;
             challengeVerification = remeda.omit(verificationFromPending, ["pendingApprovalSuccess"]);
@@ -264,7 +494,7 @@ const getChallengeVerification = async (challengeRequestMessage, community, getC
     return challengeVerification;
 };
 // get the data to be published publicly to community.challenges
-const getCommunityChallengeFromCommunityChallengeSettings = async (communityChallengeSettings, pkc) => {
+const getCommunityChallengeFromCommunityChallengeSettings = async ({ communityChallengeSettings, pkc }) => {
     communityChallengeSettings = CommunityChallengeSettingSchema.parse(communityChallengeSettings);
     // if the challenge is an external file, fetch it and override the communityChallengeSettings values
     let challengeFile = undefined;
@@ -287,19 +517,21 @@ const getCommunityChallengeFromCommunityChallengeSettings = async (communityChal
     }
     // else, the challenge is included with pkc-js or user-defined
     else if (communityChallengeSettings.name) {
-        const ChallengeFileFactory = ChallengeFileFactorySchema.parse(resolveChallengeFactoryByName(communityChallengeSettings.name, pkc));
+        const ChallengeFileFactory = ChallengeFileFactorySchema.parse(resolveChallengeFactoryByName({ name: communityChallengeSettings.name, pkc }).factory);
         challengeFile = ChallengeFileSchema.parse(ChallengeFileFactory({ challengeSettings: communityChallengeSettings }));
     }
     if (!challengeFile)
         throw Error("Failed to load challenge file");
     const { challenge, type } = challengeFile;
     return {
-        exclude: communityChallengeSettings.exclude,
-        description: communityChallengeSettings.description || challengeFile.description,
-        challenge,
-        type,
-        caseInsensitive: challengeFile.caseInsensitive,
-        pendingApproval: communityChallengeSettings.pendingApproval
+        communityChallenge: {
+            exclude: communityChallengeSettings.exclude,
+            description: communityChallengeSettings.description || challengeFile.description,
+            challenge,
+            type,
+            caseInsensitive: challengeFile.caseInsensitive,
+            pendingApproval: communityChallengeSettings.pendingApproval
+        }
     };
 };
 export { pkcJsChallenges, getPendingChallengesOrChallengeVerification, getChallengeVerificationFromChallengeAnswers, getChallengeVerification, getCommunityChallengeFromCommunityChallengeSettings };