@sealkeeper/schema 0.4.7 → 0.4.9

package/dist/seal-conformance.js

@@ -18,6 +18,29 @@ const COUNTED = {
     server_checked_tasks: 0,
     confirmed_tasks: 0,
 };
+// The three posted counts of a version 3 SEAL, and a fingerprint hash,
+// SHA-256 of some bytes in base64url, 43 characters.
+const POSTED = {
+    posted_tasks: 4,
+    posted_distinct_operators: 2,
+    posted_confirmed_tasks: 1,
+};
+const FINGERPRINT_HASH = 'BwjgHg-Z9sC4K05UnygMCN_CD7onYm12GfK83VEIpTQ';
+// The counted evidence of a version 3 SEAL, COUNTED plus the counted twins
+// of posted_tasks and posted_confirmed_tasks, each at most its raw count.
+const COUNTED_V3 = {
+    ...COUNTED,
+    posted_tasks: 3,
+    posted_confirmed_tasks: 1,
+};
+// trust and top_categories of a version 4 SEAL. Three categories highest
+// first, the tie of data and math in category order, data before math.
+const TRUST = 412;
+const TOP_CATEGORIES = [
+    { category: 'code', score: 230 },
+    { category: 'data', score: 90 },
+    { category: 'math', score: 90 },
+];
 const header = (kid) => base64urlEncode(utf8Encode(JSON.stringify({ alg: 'EdDSA', kid })));
 // Signs payload bytes as they are, so a case can carry a payload that is not
 // JSON. sign() in envelope.ts always writes JSON.
@@ -54,6 +77,22 @@ export async function sealConformanceCases() {
         last_active: NOW - HOUR,
         dormant_days: 0,
     };
+    // Version 3 is version 2 without version, with the posted counts,
+    // fingerprint and state.
+    const { version: _dropped, ...v2Fields } = base;
+    const v3 = {
+        ...v2Fields,
+        ver: 3,
+        counts: { ...base.counts, ...POSTED },
+        counted: COUNTED_V3,
+        fingerprint: { hash: FINGERPRINT_HASH, at: NOW - 2 * HOUR },
+        state: 'matches',
+    };
+    const { state: _state, ...v3NoState } = v3;
+    // Version 4 is version 3 with trust and top_categories.
+    const v4 = { ...v3, ver: 4, trust: TRUST, top_categories: TOP_CATEGORIES };
+    const { trust: _trust, ...v4NoTrust } = v4;
+    const { top_categories: _top, ...v4NoTop } = v4;
     const signed = (payload) => sign(payload, pair.privateKey, KID);
     const valid = await signed(base);
     const [h, , s] = valid.split('.');
@@ -108,14 +147,187 @@ export async function sealConformanceCases() {
             }),
             'malformed',
         ],
-        ['an unknown ver', signed({ ...base, ver: 3 }), 'unsupported_version'],
+        [
+            'version 3 with posted counts, fingerprint and state',
+            signed(v3),
+            'valid',
+        ],
+        [
+            'version 3 with no fingerprint yet and a reserved state',
+            signed({ ...v3, fingerprint: null, state: 'provisional' }),
+            'valid',
+        ],
+        [
+            'version 3 with a field it does not define',
+            signed({ ...v3, extra: true }),
+            'malformed',
+        ],
+        ['version 3 without state', signed(v3NoState), 'malformed'],
+        [
+            'version 3 with a state outside the set',
+            signed({ ...v3, state: 'unknown' }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint hash of the wrong length',
+            signed({
+                ...v3,
+                fingerprint: { hash: FINGERPRINT_HASH.slice(1), at: NOW - HOUR },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with the dropped version field',
+            signed({ ...v3, version: '1.0.0' }),
+            'malformed',
+        ],
+        [
+            'version 3 without the posted counts',
+            signed({ ...v3, counts: base.counts }),
+            'malformed',
+        ],
+        [
+            'version 3 with a counted posted value above its count',
+            signed({
+                ...v3,
+                counted: { ...COUNTED_V3, posted_tasks: 5 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with the version 2 counted evidence',
+            signed({ ...v3, counted: COUNTED }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint after iat',
+            signed({
+                ...v3,
+                fingerprint: { hash: FINGERPRINT_HASH, at: v3.iat + 1 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with a fingerprint hash whose last character no SHA-256 has',
+            signed({
+                ...v3,
+                fingerprint: {
+                    hash: `${FINGERPRINT_HASH.slice(0, 42)}R`,
+                    at: NOW - HOUR,
+                },
+            }),
+            'malformed',
+        ],
+        [
+            'version 3 with more posted confirmed tasks than posted tasks',
+            signed({
+                ...v3,
+                counts: { ...v3.counts, posted_confirmed_tasks: 5 },
+            }),
+            'malformed',
+        ],
+        [
+            'version 2 with a fingerprint and state',
+            signed({
+                ...base,
+                ver: 2,
+                counted: COUNTED,
+                fingerprint: v3.fingerprint,
+                state: 'matches',
+            }),
+            'malformed',
+        ],
+        ['version 4 with a Trust Score and top categories', signed(v4), 'valid'],
+        [
+            'version 4 with no category yet',
+            signed({ ...v4, trust: 0, top_categories: [] }),
+            'valid',
+        ],
+        [
+            'version 4 with a field it does not define',
+            signed({ ...v4, extra: true }),
+            'malformed',
+        ],
+        ['version 4 without trust', signed(v4NoTrust), 'malformed'],
+        ['version 4 without top_categories', signed(v4NoTop), 'malformed'],
+        [
+            'version 4 with a Trust Score that is not a whole number',
+            signed({ ...v4, trust: 412.5 }),
+            'malformed',
+        ],
+        [
+            'version 4 with a negative Trust Score',
+            signed({ ...v4, trust: -1 }),
+            'malformed',
+        ],
+        [
+            'version 4 with four top categories',
+            signed({
+                ...v4,
+                top_categories: [...TOP_CATEGORIES, { category: 'writing', score: 10 }],
+            }),
+            'malformed',
+        ],
+        [
+            'version 4 with top categories lowest first',
+            signed({ ...v4, top_categories: [...TOP_CATEGORIES].reverse() }),
+            'malformed',
+        ],
+        [
+            'version 4 with a tie out of category order',
+            signed({
+                ...v4,
+                top_categories: [
+                    TOP_CATEGORIES[0],
+                    TOP_CATEGORIES[2],
+                    TOP_CATEGORIES[1],
+                ],
+            }),
+            'malformed',
+        ],
+        [
+            'version 4 with one category twice',
+            signed({
+                ...v4,
+                top_categories: [TOP_CATEGORIES[0], TOP_CATEGORIES[0]],
+            }),
+            'malformed',
+        ],
+        [
+            'version 4 with a category the standard does not name',
+            signed({
+                ...v4,
+                top_categories: [{ category: 'Data Work', score: 90 }],
+            }),
+            'malformed',
+        ],
+        [
+            'version 4 with a category score that is not a whole number',
+            signed({
+                ...v4,
+                top_categories: [{ category: 'code', score: 0.5 }],
+            }),
+            'malformed',
+        ],
+        [
+            'version 4 with the dropped version field',
+            signed({ ...v4, version: '1.0.0' }),
+            'malformed',
+        ],
+        [
+            'version 3 with trust and top_categories',
+            signed({ ...v4, ver: 3 }),
+            'malformed',
+        ],
+        ['an unknown ver', signed({ ...base, ver: 5 }), 'unsupported_version'],
         [
             'no ver after the legacy cutoff',
             signed({ ...base, ver: undefined }),
             'unsupported_version',
         ],
         // Intended. Platinum is reserved on LADDER and is not a Level under ver
-        // 1 or 2 (standard, section 9). It becomes valid only with a ver bump.
+        // 1, 2, 3 or 4 (standard, section 9). It becomes valid only with a ver
+        // bump.
         [
             'the wrong shape, a level not in the standard',
             signed({ ...base, level: 'platinum' }),
@@ -126,6 +338,55 @@ export async function sealConformanceCases() {
             signed({ ...base, scores: { reliability: 1.2 } }),
             'malformed',
         ],
+        // Competence is keyed by category from RT-3. A SEAL issued before it
+        // carries competence by task type, and a verifier accepts both
+        // (standard, section 2). Any of the eight stored categories is valid,
+        // math, which a poster can choose from D-UI-12, and conversation and
+        // other, which are no longer offered but past tasks keep.
+        [
+            'competence by category',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:data': 0.8 },
+            }),
+            'valid',
+        ],
+        [
+            'competence in math',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:math': 0.8 },
+            }),
+            'valid',
+        ],
+        [
+            'competence in conversation and other, kept by past tasks',
+            signed({
+                ...base,
+                scores: {
+                    ...base.scores,
+                    'competence:conversation': 0.7,
+                    'competence:other': 0.6,
+                },
+            }),
+            'valid',
+        ],
+        [
+            'competence by task type, issued before categories',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:csv_normalise': 0.8 },
+            }),
+            'valid',
+        ],
+        [
+            'a competence key that is not a task type',
+            signed({
+                ...base,
+                scores: { ...base.scores, 'competence:Data Work': 0.8 },
+            }),
+            'malformed',
+        ],
         [
             'a negative count',
             signed({

package/dist/standing.d.ts

@@ -37,6 +37,20 @@ export declare const StandingCounts: z.ZodObject<{
     safety_incidents_90d: z.ZodInt;
 }, z.core.$strict>;
 export type StandingCounts = z.infer<typeof StandingCounts>;
+export declare const StandingCountsV3: z.ZodObject<{
+    events: z.ZodInt;
+    history_days: z.ZodInt;
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    distinct_operators: z.ZodInt;
+    safety_incidents_90d: z.ZodInt;
+    posted_tasks: z.ZodInt;
+    posted_distinct_operators: z.ZodInt;
+    posted_confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type StandingCountsV3 = z.infer<typeof StandingCountsV3>;
 export declare const CountedCounts: z.ZodObject<{
     verified_tasks: z.ZodInt;
     seed_tasks: z.ZodInt;
@@ -44,10 +58,52 @@ export declare const CountedCounts: z.ZodObject<{
     confirmed_tasks: z.ZodInt;
 }, z.core.$strict>;
 export type CountedCounts = z.infer<typeof CountedCounts>;
+export declare const CountedCountsV3: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    posted_tasks: z.ZodInt;
+    posted_confirmed_tasks: z.ZodInt;
+}, z.core.$strict>;
+export type CountedCountsV3 = z.infer<typeof CountedCountsV3>;
+export declare const AnswerCounts: z.ZodObject<{
+    events: z.ZodInt;
+    history_days: z.ZodInt;
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    distinct_operators: z.ZodInt;
+    safety_incidents_90d: z.ZodInt;
+    posted_tasks: z.ZodOptional<z.ZodInt>;
+    posted_distinct_operators: z.ZodOptional<z.ZodInt>;
+    posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AnswerCounts = z.infer<typeof AnswerCounts>;
+export declare const AnswerCounted: z.ZodObject<{
+    verified_tasks: z.ZodInt;
+    seed_tasks: z.ZodInt;
+    server_checked_tasks: z.ZodInt;
+    confirmed_tasks: z.ZodInt;
+    posted_tasks: z.ZodOptional<z.ZodInt>;
+    posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AnswerCounted = z.infer<typeof AnswerCounted>;
 export declare const COUNTED_EVIDENCE: {
     readonly dailyCeiling: 20;
     readonly diminishingK: 25;
+    readonly pairCurve: {
+        readonly free: 5;
+        readonly k: 5;
+        readonly windowDays: 30;
+    };
+    readonly operatorShareCap: {
+        readonly share: 0.5;
+        readonly floor: 5;
+    };
 };
+export declare const POSTER_RESPONSE_HOURS = 48;
 export declare const DAY_MS = 86400000;
 export declare const DORMANCY: {
     readonly quietDays: 14;
@@ -55,24 +111,49 @@ export declare const DORMANCY: {
     readonly dropTwoDays: 60;
     readonly noneDays: 90;
 };
+export declare const TRUST_SCORE: {
+    readonly decay: {
+        readonly fullDays: 30;
+        readonly zeroDays: 180;
+    };
+    readonly diversityWeight: 1.1;
+    readonly diversityMinTasks: 5;
+    readonly operatorK: 2;
+    readonly seriesDays: 30;
+    readonly deltaDays: 7;
+    readonly rankMax: 10000;
+    readonly rankWeeks: 8;
+};
+export declare function trustWeekOf(at: Date): string;
+export declare const SAFETY_MEASURED: boolean;
 export declare const LEVEL_THRESHOLDS: {
     readonly bronze: {
         readonly verifiedTasks: 25;
+        readonly trustScore: 50;
         readonly historyDays: 3;
         readonly reliability: 0.8;
         readonly incidents90d: 0;
+        readonly postedTasks: 5;
+        readonly postedOperators: 1;
+        readonly postedConfirmedTasks: 0;
     };
     readonly silver: {
         readonly verifiedTasks: 200;
+        readonly trustScore: 400;
+        readonly trustCategories: 2;
         readonly historyDays: 30;
         readonly reliability: 0.9;
         readonly safety: 0.9;
         readonly incidents90d: 0;
         readonly provenance: 0.8;
         readonly modelDeclared: true;
+        readonly postedTasks: 40;
+        readonly postedOperators: 5;
+        readonly postedConfirmedTasks: 10;
     };
     readonly gold: {
         readonly verifiedTasks: 200;
+        readonly trustScore: 400;
         readonly confirmedTasks: 25;
         readonly confirmedOperators: 3;
         readonly historySpanDays: 90;
@@ -81,6 +162,9 @@ export declare const LEVEL_THRESHOLDS: {
         readonly safety: 0.95;
         readonly cleanDays: 180;
         readonly operatorVerified: true;
+        readonly postedTasks: 40;
+        readonly postedOperators: 5;
+        readonly postedConfirmedTasks: 25;
     };
 };
 export declare const OPERATOR_SILVER_CAP: {
@@ -99,16 +183,22 @@ export declare const Standing: z.ZodObject<{
         confirmed_tasks: z.ZodInt;
         distinct_operators: z.ZodInt;
         safety_incidents_90d: z.ZodInt;
+        posted_tasks: z.ZodOptional<z.ZodInt>;
+        posted_distinct_operators: z.ZodOptional<z.ZodInt>;
+        posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
     counted: z.ZodObject<{
         verified_tasks: z.ZodInt;
         seed_tasks: z.ZodInt;
         server_checked_tasks: z.ZodInt;
         confirmed_tasks: z.ZodInt;
+        posted_tasks: z.ZodOptional<z.ZodInt>;
+        posted_confirmed_tasks: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
     history_days: z.ZodInt;
     last_active: z.ZodNullable<z.ZodISODateTime>;
     dormant_days: z.ZodNullable<z.ZodInt>;
     quiet: z.ZodBoolean;
+    held: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type Standing = z.infer<typeof Standing>;