@agentsgot/agent-kit 0.0.0-stage → 1.0.0

package/vendor/shared/src/params/index.ts

@@ -0,0 +1,139 @@
+import { z } from "zod";
+
+import rawDefaults from "../../params/params.json" with { type: "json" };
+import rawRanges from "../../params/ranges.json" with { type: "json" };
+
+export type Params = typeof rawDefaults;
+export type RuleParams = Params;
+
+type Range = { fixed?: boolean; min?: number; max?: number; maxKey?: keyof Params };
+
+const parameterRecordSchema = z.record(z.string(), z.number().finite().nullable());
+const parameterKeys = Object.keys(rawDefaults) as (keyof Params)[];
+const ranges = rawRanges as Record<keyof Params, Range>;
+
+function assertInvariant(condition: boolean, message: string): asserts condition {
+  if (!condition) throw new Error(`Invalid rule parameters: ${message}`);
+}
+
+function validateParams(candidate: unknown): Params {
+  const values = parameterRecordSchema.parse(candidate) as Record<string, number | null>;
+  assertInvariant(
+    Object.keys(values).length === parameterKeys.length,
+    "parameter key count differs from params.json",
+  );
+  for (const key of parameterKeys) {
+    assertInvariant(Object.hasOwn(values, key), `missing ${key}`);
+    const value = values[key];
+    const range = ranges[key];
+    if (value === undefined || range === undefined)
+      throw new Error(`Invalid rule parameters: missing ${key}`);
+    if (value === null) {
+      assertInvariant(rawDefaults[key] === null, `${key} may not be null`);
+      continue;
+    }
+    if (range.min !== undefined)
+      assertInvariant(value >= range.min, `${key} is below ${range.min}`);
+    const maximum = range.maxKey === undefined ? range.max : values[range.maxKey];
+    if (maximum !== undefined && maximum !== null) {
+      assertInvariant(value <= maximum, `${key} is above ${maximum}`);
+    }
+    if (range.fixed === true) assertInvariant(value === rawDefaults[key], `${key} is fixed`);
+  }
+
+  const get = (key: keyof Params) => {
+    const value = values[key];
+    if (value === null || value === undefined) throw new Error(`Expected numeric parameter ${key}`);
+    return value;
+  };
+
+  assertInvariant(
+    get("deductionExecBps") +
+      get("deductionTestBps") +
+      get("deductionRevBps") +
+      get("deductionPlatBps") ===
+      10_000,
+    "legacy deduction shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("emissionPlatformBps") +
+      get("emissionExecBps") +
+      get("emissionTestBps") +
+      get("emissionArbBps") ===
+      10_000,
+    "emission shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("vestingT0Bps") + get("vestingT1Bps") + (10_000 - get("vestingT0Bps") - get("vestingT1Bps")) ===
+      10_000,
+    "vesting shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("tradeTaxBurnShareBps") +
+      get("tradeTaxPlatformShareBps") +
+      get("tradeTaxLiquidityShareBps") ===
+      10_000,
+    "trade tax shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("caseFeeMajorityShareBps") + get("caseFeeWinnerShareBps") + get("caseFeePlatformShareBps") ===
+      10_000,
+    "case fee shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("overturnPlatformShareBps") + get("overturnRighteousShareBps") === 10_000,
+    "overturn shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("testerMinStakeAgt") <= get("arbitratorMinStakeAgt") &&
+      get("arbitratorMinStakeAgt") <= get("validatorStakeAgt.voluntaryMax"),
+    "role thresholds must satisfy tester <= arbitrator <= voluntary maximum",
+  );
+  assertInvariant(
+    get("testerWeightCapAgt") >= get("testerMinStakeAgt") &&
+      get("arbitratorWeightCapAgt") >= get("arbitratorMinStakeAgt"),
+    "weight caps must not be below their role thresholds",
+  );
+  assertInvariant(
+    get("collusionReporterRewardBps") + get("collusionArbPoolShareBps") === 10_000,
+    "collusion shares must total 10000 bps",
+  );
+  assertInvariant(
+    get("tierDailyFee.T1") < get("tierDailyFee.T2") &&
+      get("tierDailyFee.T2") < get("tierDailyFee.T3") &&
+      get("tierDailyFee.T3") < get("tierDailyFee.T4") &&
+      get("tierDailyFee.T4") < get("tierDailyFee.T5"),
+    "tier daily fees must be strictly increasing",
+  );
+  for (const tier of ["T1", "T2", "T3", "T4", "T5"] as const) {
+    assertInvariant(
+      get(`tierDaysMin.${tier}` as keyof Params) <= get(`tierDaysMax.${tier}` as keyof Params),
+      `tierDaysMin.${tier} must not exceed tierDaysMax.${tier}`,
+    );
+  }
+  assertInvariant(
+    get("passingThresholdMin") <= get("passingThresholdDefault") &&
+      get("passingThresholdDefault") <= get("passingThresholdMax"),
+    "passing threshold default must be within min–max range",
+  );
+  assertInvariant(
+    get("junkThreshold") < get("passingThresholdMin"),
+    "junk threshold must be below passing threshold min",
+  );
+  assertInvariant(
+    get("participantsMin") <= get("participantsDefault") &&
+      get("participantsDefault") <= get("participantsWarning") &&
+      get("participantsWarning") <= get("participantsMax"),
+    "participant limits must satisfy min <= default <= warning <= max",
+  );
+  // unrecoverableCostBps is deprecated in economic model v3 and retained for
+  // historical rule compatibility; computeTaskDailyEmission uses a fixed rho of 0.8.
+
+  return values as Params;
+}
+
+export const defaultParams: Params = Object.freeze(validateParams(rawDefaults));
+
+export function loadParams(overrides: Partial<Params> = {}): Params {
+  return Object.freeze(validateParams({ ...rawDefaults, ...overrides }));
+}

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

@@ -0,0 +1,235 @@
+import { z } from "zod";
+
+const Hex32Schema = z.string().regex(/^0x[0-9a-fA-F]{64}$/u);
+const AddressSchema = z.string().regex(/^0x[0-9a-fA-F]{40}$/u);
+const SignatureSchema = z.string().regex(/^0x[0-9a-fA-F]{130}$/u);
+const UintStringSchema = z.string().regex(/^(0|[1-9][0-9]*)$/u);
+
+export const CidV1Schema = z.string().regex(/^b[a-z2-7]{10,}$/u);
+
+export const ProtocolProofDomainSchema = z.object({
+  name: z.literal("AgentGrid Protocol"),
+  version: z.literal("1"),
+  chainId: z.number().int().positive(),
+  verifyingContract: AddressSchema,
+});
+
+export const ExecutorDeliverySchema = z.object({
+  taskId: Hex32Schema,
+  cidHash: Hex32Schema,
+});
+
+export const TesterAssignmentSchema = z.object({
+  taskId: Hex32Schema,
+  executor: AddressSchema,
+  testersHash: Hex32Schema,
+  seedCommitment: Hex32Schema,
+  executorTier: z.number().int().min(0).max(3),
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+});
+
+export const TestReportProofSchema = z.object({
+  taskId: Hex32Schema,
+  cidHash: Hex32Schema,
+  executor: AddressSchema,
+  conclusionsHash: Hex32Schema,
+  approved: z.boolean(),
+  signature: SignatureSchema.optional(),
+});
+
+export const AssignmentVoucherSchema = z.object({
+  taskId: Hex32Schema,
+  executor: AddressSchema,
+  issuedAt: UintStringSchema,
+  expiresAt: UintStringSchema,
+  nonce: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const PublisherProfileProofSchema = z.object({
+  publisher: AddressSchema,
+  completedTasks: z.number().int().min(0).max(0xffff_ffff),
+  reputation: z.number().int().min(0).max(2),
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const TesterTimeoutProofSchema = z.object({
+  taskId: Hex32Schema,
+  tester: AddressSchema,
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const ArbitrationCaseProofSchema = z.object({
+  caseId: Hex32Schema,
+  taskId: Hex32Schema,
+  criteriaHash: Hex32Schema,
+  evidenceHash: Hex32Schema,
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const CollusionReportProofSchema = z.object({
+  juror: AddressSchema,
+  reporter: AddressSchema,
+  evidenceHash: Hex32Schema,
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const HourlyAnchorProofSchema = z.object({
+  hourId: UintStringSchema,
+  recordsRoot: Hex32Schema,
+  poolSnapshotRoot: Hex32Schema,
+  seatSnapshotRoot: Hex32Schema,
+  nonce: UintStringSchema,
+  deadline: UintStringSchema,
+  signature: SignatureSchema.optional(),
+});
+
+export const PROTOCOL_PROOF_TYPES = {
+  ExecutorDelivery: [
+    { name: "taskId", type: "bytes32" },
+    { name: "cidHash", type: "bytes32" },
+  ],
+  TesterAssignment: [
+    { name: "taskId", type: "bytes32" },
+    { name: "executor", type: "address" },
+    { name: "testersHash", type: "bytes32" },
+    { name: "seedCommitment", type: "bytes32" },
+    { name: "executorTier", type: "uint8" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  TestReport: [
+    { name: "taskId", type: "bytes32" },
+    { name: "cidHash", type: "bytes32" },
+    { name: "executor", type: "address" },
+    { name: "conclusionsHash", type: "bytes32" },
+    { name: "approved", type: "bool" },
+  ],
+  AssignmentVoucher: [
+    { name: "taskId", type: "bytes32" },
+    { name: "executor", type: "address" },
+    { name: "issuedAt", type: "uint64" },
+    { name: "expiresAt", type: "uint64" },
+    { name: "nonce", type: "uint256" },
+  ],
+  PublisherProfile: [
+    { name: "publisher", type: "address" },
+    { name: "completedTasks", type: "uint64" },
+    { name: "reputation", type: "uint8" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  TesterTimeout: [
+    { name: "taskId", type: "bytes32" },
+    { name: "tester", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  ArbitrationCase: [
+    { name: "caseId", type: "bytes32" },
+    { name: "taskId", type: "bytes32" },
+    { name: "criteriaHash", type: "bytes32" },
+    { name: "evidenceHash", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  CollusionReport: [
+    { name: "juror", type: "address" },
+    { name: "reporter", type: "address" },
+    { name: "evidenceHash", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  EmissionHours: [
+    { name: "fromHour", type: "uint64" },
+    { name: "toHour", type: "uint64" },
+    { name: "hoursHash", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+  Settlement: [
+    { name: "taskId", type: "bytes32" },
+    { name: "resultsHash", type: "bytes32" },
+    { name: "lockedTier", type: "uint8" },
+    { name: "lockedAt", type: "uint64" },
+    { name: "billedUntil", type: "uint64" },
+    { name: "deductionAgt", type: "uint256" },
+    { name: "executorPoolPi", type: "uint256" },
+    { name: "hourId", type: "uint64" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint64" },
+  ],
+} as const;
+
+export function assertProtocolProofBounds(
+  input:
+    | { kind: "PUBLISHER_PROFILE"; completedTasks: number; reputation: number }
+    | {
+        kind: "ARBITRATION_CASE";
+        criterionCount: number;
+        excludedCount: number;
+        sourceCount: number;
+        weightBps: readonly number[];
+      },
+): void {
+  if (input.kind === "PUBLISHER_PROFILE") {
+    if (
+      !Number.isInteger(input.completedTasks) ||
+      input.completedTasks < 0 ||
+      input.completedTasks > 0xffff_ffff ||
+      !Number.isInteger(input.reputation) ||
+      input.reputation < 0 ||
+      input.reputation > 2
+    )
+      throw new RangeError("PUBLISHER_PROFILE_OUT_OF_BOUNDS");
+    return;
+  }
+
+  const weightTotal = input.weightBps.reduce((sum, value) => sum + value, 0);
+  if (
+    input.criterionCount < 1 ||
+    input.criterionCount > 64 ||
+    input.excludedCount > 256 ||
+    input.sourceCount > 256 ||
+    input.weightBps.length !== input.criterionCount ||
+    weightTotal !== 10_000
+  )
+    throw new RangeError("ARBITRATION_CASE_OUT_OF_BOUNDS");
+}
+
+const BASE32 = "abcdefghijklmnopqrstuvwxyz234567";
+
+export function base32Lower(bytes: Uint8Array): string {
+  let result = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = (buffer << 8) | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      result += BASE32[(buffer >>> bits) & 31];
+    }
+  }
+  if (bits > 0) result += BASE32[(buffer << (5 - bits)) & 31];
+  return result;
+}
+
+/** CIDv1 for a raw block using sha2-256, matching Kubo block/put with format=raw. */
+export async function rawCidV1(content: Uint8Array): Promise<string> {
+  const copy = Uint8Array.from(content);
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", copy.buffer));
+  const cid = new Uint8Array(4 + digest.length);
+  cid.set([0x01, 0x55, 0x12, 0x20]);
+  cid.set(digest, 4);
+  return `b${base32Lower(cid)}`;
+}