@agentsgot/agent-kit 0.0.0-stage → 1.0.0

package/vendor/shared/test/fixtures.ts

@@ -0,0 +1,65 @@
+import {
+  AcceptanceGrade,
+  AllocationMode,
+  type Criterion,
+  type DraftField,
+  type TaskDraft,
+  TaskTemplate,
+  Tier,
+} from "../src/index.js";
+
+export const criterionA: Criterion = {
+  id: "criterion-a",
+  description: "The machine check passes",
+  grade: AcceptanceGrade.A,
+  weightBps: 10_000,
+  machineCheck: { kind: "REGEX", commandOrSchema: "Tests? passed", expected: "" },
+};
+
+export function field<T>(value: T, source: "user" | "ai" | "rule" = "user"): DraftField<T> {
+  return {
+    value,
+    source,
+    confirmation: "confirmed",
+    updatedAt: "2030-01-01T00:00:00Z",
+  };
+}
+
+export function makeDraft(): TaskDraft {
+  return {
+    id: "draft-1",
+    sessionId: "session-1",
+    publisher: "0x1111111111111111111111111111111111111111",
+    version: 3,
+    fields: {
+      title: field("Implement a deterministic rule"),
+      summary: field("Implement and verify one deterministic rule module."),
+      template: field(TaskTemplate.Translation),
+      deliverables: field(["Source code", "Tests"]),
+      outOfScope: field([]),
+      constraints: field([]),
+      inputs: field([]),
+      criteria: field([field(criterionA)]),
+      estimatedHours: field(1),
+      startTier: field(Tier.T1),
+      maxTier: field(Tier.T1),
+      runDays: field(3),
+      allocationMode: field(AllocationMode.ProRata, "rule"),
+      topK: field(null),
+      maxParticipants: field(9),
+      passingThreshold: field(60),
+      minimumTier: field(Tier.T1, "rule"),
+      cost: field(
+        {
+          reserve: (300n * 10n ** 18n * 3n).toString(),
+          dailyFee: (300n * 10n ** 18n).toString(),
+        },
+        "rule",
+      ),
+    },
+    summarizedUpToMessageId: "message-1",
+    lastSummarizedAt: "2030-01-01T00:00:00Z",
+    pendingSuggestions: [],
+    status: "FROZEN",
+  };
+}

package/vendor/shared/test/params.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import paramsJson from "../params/params.json";
+import { defaultParams, loadParams } from "../src/index.js";
+
+describe("parameter source", () => {
+  it("loads immutable defaults", () => {
+    expect(loadParams()).toEqual(defaultParams);
+    expect(Object.isFrozen(defaultParams)).toBe(true);
+  });
+
+  it("accepts an in-range override", () => {
+    expect(loadParams({ "tierDailyFee.T1": 500 })["tierDailyFee.T1"]).toBe(500);
+  });
+
+  it.each([
+    ["tokenTotalAgt", 999],
+    ["tierDailyFee.T1", 2000],
+    ["deductionExecBps", 11_000],
+  ] as const)("rejects invalid override %s=%s", (key, value) => {
+    expect(() => loadParams({ [key]: value })).toThrow(/Invalid rule parameters/u);
+  });
+
+  it("rejects a broken deduction split", () => {
+    expect(() => loadParams({ deductionExecBps: 6000 })).toThrow(/deduction shares/u);
+  });
+
+  it("rejects a broken emission split", () => {
+    expect(() => loadParams({ emissionExecBps: 6000 })).toThrow(/emission shares/u);
+  });
+
+  it("rejects a broken trade tax sum", () => {
+    expect(() => loadParams({ tradeTaxBurnShareBps: 6000 })).toThrow(/trade tax shares/u);
+  });
+
+  it("rejects a broken case fee sum (fixed params are caught first)", () => {
+    expect(() => loadParams({ caseFeeMajorityShareBps: 6000 })).toThrow(/Invalid rule parameters/u);
+  });
+
+  it("rejects non-increasing tier fees (range check catches first)", () => {
+    expect(() =>
+      loadParams({ "tierDailyFee.T1": 500, "tierDailyFee.T2": 400 }),
+    ).toThrow(/Invalid rule parameters/u);
+  });
+
+  it("has all keys defined in params.json", () => {
+    expect(Object.keys(defaultParams).length).toBe(Object.keys(paramsJson).length);
+  });
+});

package/vendor/shared/test/properties.test.ts

@@ -0,0 +1,136 @@
+import fc from "fast-check";
+import { describe, expect, it } from "vitest";
+
+import {
+  AcceptanceGrade,
+  AllocationMode,
+  allocateExecutorPool,
+  antiWashCheck,
+  computeDeduction,
+  cumulativeReleased,
+  buildSchedule,
+  computeMinimumTier,
+  computeReserve,
+  defaultParams,
+  Tier,
+  TaskTemplate,
+  vestingSchedule,
+} from "../src/index.js";
+import { criterionA } from "./fixtures.js";
+
+const tierRank = { T1: 1, T2: 2, T3: 3, T4: 4, T5: 5 } as const;
+
+describe("rule properties", () => {
+  it("reserve equals fee × days", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(Tier.T1, Tier.T2, Tier.T3, Tier.T4, Tier.T5),
+        fc.integer({ min: 1, max: 60 }),
+        (tier, days) => {
+          const reserve = computeReserve(tier, days, defaultParams);
+          expect(reserve).toBeGreaterThan(0n);
+        },
+      ),
+    );
+  });
+
+  it("deduction ≤ reserve for any billing period up to runDays", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(Tier.T1, Tier.T2, Tier.T3, Tier.T4, Tier.T5),
+        fc.integer({ min: 1, max: 60 }),
+        (tier, days) => {
+          const reserve = computeReserve(tier, days, defaultParams);
+          const deduction = computeDeduction(tier, BigInt(days * 86_400), defaultParams);
+          expect(deduction).toBeLessThanOrEqual(reserve);
+        },
+      ),
+    );
+  });
+
+  it("vesting schedule sums to exact amount", () => {
+    fc.assert(
+      fc.property(fc.bigInt({ min: 1n, max: 10n ** 18n }), (amount) => {
+        const schedule = vestingSchedule(amount, 1_000_000, defaultParams);
+        expect(schedule.reduce((sum, t) => sum + t.amount, 0n)).toBe(amount);
+        expect(schedule).toHaveLength(3);
+        for (const tranche of schedule) expect(tranche.amount).toBeGreaterThanOrEqual(0n);
+      }),
+    );
+  });
+
+  it("minimum tier is monotone in hours", () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 500 }),
+        fc.integer({ min: 0, max: 500 }),
+        (hoursBase, hoursDelta) => {
+          const base = computeMinimumTier({
+            criteria: [criterionA],
+            estimatedHours: hoursBase,
+            template: TaskTemplate.Translation,
+          });
+          const increased = computeMinimumTier({
+            criteria: [criterionA],
+            estimatedHours: hoursBase + hoursDelta,
+            template: TaskTemplate.Translation,
+          });
+          expect(tierRank[increased]).toBeGreaterThanOrEqual(tierRank[base]);
+        },
+      ),
+    );
+  });
+
+  it("allocation conserves pool for every mode", () => {
+    fc.assert(
+      fc.property(
+        fc.bigInt({ min: 1n, max: 10n ** 12n }),
+        fc.constantFrom(
+          AllocationMode.WinnerTakesAll,
+          AllocationMode.TopK,
+          AllocationMode.ProRata,
+        ),
+        fc.array(
+          fc.record({
+            submissionIndex: fc.integer({ min: 1, max: 100 }),
+            score: fc.integer({ min: 0, max: 100 }),
+            passes: fc.boolean(),
+          }),
+          { minLength: 1, maxLength: 10 },
+        ),
+        (pool, mode, scores) => {
+          const result = allocateExecutorPool(pool, scores, mode, 3);
+          const total = result.reduce((sum, r) => sum + r.amount, 0n);
+          if (result.length > 0) {
+            expect(total).toBe(pool);
+          }
+          for (const r of result) expect(r.amount).toBeGreaterThanOrEqual(0n);
+        },
+      ),
+    );
+  });
+
+  it("cumulative released is nonnegative and at most B0", () => {
+    const B0 = 800_000_000n * 10n ** 18n;
+    const schedule = buildSchedule({
+      startTime: 1_700_000_000n,
+      initialBalance: B0,
+      halfLifeDays: BigInt(defaultParams.emissionHalfLifeDays),
+      platformBps: BigInt(defaultParams.emissionPlatformBps),
+      execBps: BigInt(defaultParams.emissionExecBps),
+      testBps: BigInt(defaultParams.emissionTestBps),
+    });
+    fc.assert(
+      fc.property(fc.bigInt({ min: 0n, max: 10n * 365n * 24n * 3600n }), (delta) => {
+        const released = cumulativeReleased(schedule, schedule.startTime + delta);
+        expect(released).toBeGreaterThanOrEqual(0n);
+        expect(released).toBeLessThanOrEqual(B0);
+      }),
+    );
+  });
+
+  it("anti-wash: emission recovery is always below unrecoverable cost", () => {
+    const { ok } = antiWashCheck(defaultParams);
+    expect(ok).toBe(true);
+  });
+});

package/vendor/shared/test/protocol-proofs.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  assertProtocolProofBounds,
+  CidV1Schema,
+  PROTOCOL_PROOF_TYPES,
+  rawCidV1,
+  TesterAssignmentSchema,
+} from "../src/protocol-proofs.js";
+
+describe("protocol proof primitives", () => {
+  it("keeps the contract field order", () => {
+    expect(PROTOCOL_PROOF_TYPES.TesterAssignment.map(({ name }) => name)).toEqual([
+      "taskId",
+      "executor",
+      "testersHash",
+      "seedCommitment",
+      "executorTier",
+      "nonce",
+      "deadline",
+    ]);
+  });
+
+  it("defines every WP3Y protocol proof with the contract field order", () => {
+    expect(Object.keys(PROTOCOL_PROOF_TYPES)).toEqual([
+      "ExecutorDelivery",
+      "TesterAssignment",
+      "TestReport",
+      "AssignmentVoucher",
+      "PublisherProfile",
+      "TesterTimeout",
+      "ArbitrationCase",
+      "CollusionReport",
+      "EmissionHours",
+      "Settlement",
+    ]);
+  });
+
+  it("matches the TesterTimeout typehash field order", () => {
+    expect(PROTOCOL_PROOF_TYPES.TesterTimeout.map(({ name, type }) => `${type} ${name}`)).toEqual([
+      "bytes32 taskId",
+      "address tester",
+      "uint256 nonce",
+      "uint64 deadline",
+    ]);
+  });
+
+  it("matches the EmissionHours typehash field order", () => {
+    expect(PROTOCOL_PROOF_TYPES.EmissionHours.map(({ name }) => name)).toEqual([
+      "fromHour",
+      "toHour",
+      "hoursHash",
+      "nonce",
+      "deadline",
+    ]);
+  });
+
+  it("rejects protocol facts outside contract hard bounds", () => {
+    expect(() =>
+      assertProtocolProofBounds({
+        kind: "ARBITRATION_CASE",
+        criterionCount: 1,
+        excludedCount: 0,
+        sourceCount: 0,
+        weightBps: [9_999],
+      }),
+    ).toThrow("ARBITRATION_CASE_OUT_OF_BOUNDS");
+  });
+
+  it("computes a deterministic raw CIDv1", async () => {
+    const first = await rawCidV1(new TextEncoder().encode("agentgrid"));
+    const second = await rawCidV1(new TextEncoder().encode("agentgrid"));
+    expect(first).toBe(second);
+    expect(CidV1Schema.parse(first)).toBe(first);
+  });
+
+  it("rejects assignments that omit the executor binding", () => {
+    expect(
+      TesterAssignmentSchema.safeParse({
+        taskId: `0x${"1".repeat(64)}`,
+        testersHash: `0x${"2".repeat(64)}`,
+        seedCommitment: `0x${"3".repeat(64)}`,
+        executorTier: 0,
+        nonce: "0",
+        deadline: "1",
+      }).success,
+    ).toBe(false);
+  });
+});