scientific-protocol 0.1.0

package/dist/shared/artifact-storage-bundles.js

@@ -0,0 +1,124 @@
+import { sha256Hex } from "./sha256.js";
+const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+function stableSerialize(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue)}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function normalizeRequiredText(value, fieldName) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmed;
+}
+function normalizeOptionalText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function normalizeMemberPath(value) {
+    const normalized = normalizeRequiredText(value, "artifact bundle memberPath").replace(/\\/gu, "/");
+    const segments = normalized.split("/");
+    if (normalized.startsWith("/") ||
+        segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new Error("artifact bundle memberPath must be relative and safe");
+    }
+    return normalized;
+}
+function normalizeByteLength(value, artifactKey) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`artifact ${artifactKey} byteLength must be a non-negative safe integer`);
+    }
+    return value;
+}
+function normalizeSha256(value, artifactKey) {
+    const normalized = normalizeRequiredText(value, `artifact ${artifactKey} sha256`).toLowerCase();
+    if (!SHA256_PATTERN.test(normalized)) {
+        throw new Error(`artifact ${artifactKey} sha256 must be 64 lowercase hex characters`);
+    }
+    return normalized;
+}
+function normalizeArtifact(artifact) {
+    const artifactKey = normalizeRequiredText(artifact.artifactKey, "artifactKey");
+    return {
+        artifactKey,
+        byteLength: normalizeByteLength(artifact.byteLength, artifactKey),
+        cid: normalizeRequiredText(artifact.cid, `artifact ${artifactKey} cid`),
+        contentType: normalizeRequiredText(artifact.contentType, `artifact ${artifactKey} contentType`),
+        durabilityClass: artifact.durabilityClass,
+        memberPath: normalizeMemberPath(artifact.memberPath),
+        metadata: artifact.metadata ?? {},
+        sha256: normalizeSha256(artifact.sha256, artifactKey),
+        sourceUri: normalizeOptionalText(artifact.sourceUri),
+    };
+}
+export function buildArtifactStorageBundleManifest(input) {
+    const bundleKey = normalizeRequiredText(input.bundleKey, "bundleKey");
+    const storageRail = normalizeRequiredText(input.storageRail, "storageRail");
+    if (input.artifacts.length === 0) {
+        throw new Error("artifact storage bundle must include at least one artifact");
+    }
+    const artifacts = input.artifacts
+        .map(normalizeArtifact)
+        .sort((left, right) => left.artifactKey.localeCompare(right.artifactKey));
+    const duplicatePaths = new Set();
+    const duplicateKeys = new Set();
+    for (const artifact of artifacts) {
+        if (duplicatePaths.has(artifact.memberPath)) {
+            throw new Error(`artifact bundle memberPath duplicates ${artifact.memberPath}`);
+        }
+        if (duplicateKeys.has(artifact.artifactKey)) {
+            throw new Error(`artifact bundle artifactKey duplicates ${artifact.artifactKey}`);
+        }
+        duplicatePaths.add(artifact.memberPath);
+        duplicateKeys.add(artifact.artifactKey);
+    }
+    const baseManifest = {
+        artifacts,
+        bundleCid: normalizeOptionalText(input.bundleCid),
+        bundleKey,
+        bundleUri: normalizeOptionalText(input.bundleUri),
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        kind: "scientific.artifact-storage-bundle",
+        metadata: input.metadata ?? {},
+        storageRail,
+        version: 1,
+    };
+    return {
+        ...baseManifest,
+        manifestDigest: `sha256:${sha256Hex(stableSerialize(baseManifest))}`,
+    };
+}
+export function verifyArtifactStorageBundleManifest(manifest) {
+    const { manifestDigest: declaredDigest, ...digestInput } = manifest;
+    const expectedDigest = `sha256:${sha256Hex(stableSerialize(digestInput))}`;
+    if (declaredDigest !== expectedDigest) {
+        throw new Error(`artifact storage bundle manifestDigest mismatch: expected ${expectedDigest}, received ${declaredDigest}`);
+    }
+    return expectedDigest;
+}
+export function createArtifactStorageBundlePolicyInputs(manifest) {
+    verifyArtifactStorageBundleManifest(manifest);
+    return manifest.artifacts.map((artifact) => ({
+        artifactKey: artifact.artifactKey,
+        policy: {
+            bundleCid: manifest.bundleCid,
+            bundleMemberPath: artifact.memberPath,
+            durabilityClass: artifact.durabilityClass,
+            metadata: {
+                artifactCid: artifact.cid,
+                bundleKey: manifest.bundleKey,
+                bundleUri: manifest.bundleUri,
+                manifestDigest: manifest.manifestDigest,
+                storageRail: manifest.storageRail,
+            },
+        },
+    }));
+}

package/dist/shared/artifact-storage-policy.d.ts

@@ -0,0 +1,38 @@
+export type ArtifactDurabilityClass = "A" | "B" | "C" | "D";
+export type ArtifactStorageCommitmentKind = "filecoin" | "hot" | "institutional" | "mirror" | "provider" | "temporary";
+export type ArtifactStoragePolicyInput = {
+    bundleCid?: string | null;
+    bundleMemberPath?: string | null;
+    durabilityClass: ArtifactDurabilityClass;
+    metadata?: Record<string, unknown>;
+    repairPriority?: number;
+    requiredIndependentRetrievalPaths?: number;
+    requiredReplicaCount?: number;
+    requiresFilecoinOrEquivalent?: boolean;
+    retentionUntil?: string | null;
+};
+export type ArtifactStorageAttestationInput = {
+    attestorAddress: string;
+    cid: string;
+    commitmentKind: ArtifactStorageCommitmentKind;
+    evidenceRef?: string | null;
+    nodeId?: string | null;
+    provider: string;
+    providerMetadata?: Record<string, unknown>;
+    retentionUntil?: string | null;
+    retrievalUrl?: string | null;
+    signature: string;
+    signedPayloadHash: string;
+    storageClass: ArtifactDurabilityClass;
+    storageStartedAt?: string;
+};
+export type ArtifactStorageClassPolicy = {
+    durabilityClass: ArtifactDurabilityClass;
+    repairPriority: number;
+    requiredIndependentRetrievalPaths: number;
+    requiredReplicaCount: number;
+    requiresFilecoinOrEquivalent: boolean;
+};
+export declare const ARTIFACT_STORAGE_CLASS_POLICIES: Record<ArtifactDurabilityClass, ArtifactStorageClassPolicy>;
+export declare function defaultArtifactStoragePolicy(durabilityClass: ArtifactDurabilityClass): ArtifactStorageClassPolicy;
+export declare function resolveArtifactStoragePolicyInput(input: ArtifactStoragePolicyInput): Required<Pick<ArtifactStoragePolicyInput, "durabilityClass" | "metadata" | "repairPriority" | "requiredIndependentRetrievalPaths" | "requiredReplicaCount" | "requiresFilecoinOrEquivalent">> & Pick<ArtifactStoragePolicyInput, "bundleCid" | "bundleMemberPath" | "retentionUntil">;

package/dist/shared/artifact-storage-policy.js

@@ -0,0 +1,47 @@
+export const ARTIFACT_STORAGE_CLASS_POLICIES = {
+    A: {
+        durabilityClass: "A",
+        repairPriority: 100,
+        requiredIndependentRetrievalPaths: 2,
+        requiredReplicaCount: 2,
+        requiresFilecoinOrEquivalent: true,
+    },
+    B: {
+        durabilityClass: "B",
+        repairPriority: 50,
+        requiredIndependentRetrievalPaths: 1,
+        requiredReplicaCount: 1,
+        requiresFilecoinOrEquivalent: true,
+    },
+    C: {
+        durabilityClass: "C",
+        repairPriority: 80,
+        requiredIndependentRetrievalPaths: 1,
+        requiredReplicaCount: 1,
+        requiresFilecoinOrEquivalent: true,
+    },
+    D: {
+        durabilityClass: "D",
+        repairPriority: 10,
+        requiredIndependentRetrievalPaths: 0,
+        requiredReplicaCount: 0,
+        requiresFilecoinOrEquivalent: false,
+    },
+};
+export function defaultArtifactStoragePolicy(durabilityClass) {
+    return ARTIFACT_STORAGE_CLASS_POLICIES[durabilityClass];
+}
+export function resolveArtifactStoragePolicyInput(input) {
+    const defaults = defaultArtifactStoragePolicy(input.durabilityClass);
+    return {
+        bundleCid: input.bundleCid ?? null,
+        bundleMemberPath: input.bundleMemberPath ?? null,
+        durabilityClass: input.durabilityClass,
+        metadata: input.metadata ?? {},
+        repairPriority: input.repairPriority ?? defaults.repairPriority,
+        requiredIndependentRetrievalPaths: input.requiredIndependentRetrievalPaths ?? defaults.requiredIndependentRetrievalPaths,
+        requiredReplicaCount: input.requiredReplicaCount ?? defaults.requiredReplicaCount,
+        requiresFilecoinOrEquivalent: input.requiresFilecoinOrEquivalent ?? defaults.requiresFilecoinOrEquivalent,
+        retentionUntil: input.retentionUntil ?? null,
+    };
+}

package/dist/shared/contracts.d.ts

@@ -0,0 +1,30 @@
+import { Contract, type ContractRunner, type InterfaceAbi, JsonRpcProvider } from "ethers";
+import { type EnvRecord } from "./secrets.js";
+export type ContractName = "AccessController" | "AgentRegistry" | "AppealsRegistry" | "ArtifactRegistry" | "BondEscrow" | "ClaimRewardVault" | "ClaimRegistry" | "EpistemicMarket" | "ProtocolGovernanceToken" | "ProtocolGovernor" | "ProtocolParameters" | "ProtocolTimelock" | "ProtocolTreasury" | "ReplicationRegistry" | "ReputationCheckpointRegistry" | "ResolutionModuleRegistry";
+export type Artifact = {
+    abi: InterfaceAbi;
+    bytecode: string;
+    contractName: string;
+    sourceName: string;
+};
+export declare function loadArtifact(name: ContractName): Promise<Artifact>;
+export declare function getContract(name: ContractName, address: string, runner: ContractRunner): Promise<Contract & Record<string, any>>;
+export declare function getRpcUrl(env?: EnvRecord): string;
+export declare function getProvider(rpcUrl?: string): JsonRpcProvider;
+export declare function extractContractEventId(contract: {
+    interface: {
+        parseLog(log: unknown): {
+            args: Record<string, {
+                toString(): string;
+            }>;
+            name?: string;
+        } | null;
+    };
+}, receipt: {
+    logs: Array<unknown>;
+}, eventName: string, argName: string): string | null;
+export declare function requireContractEventId(contract: Parameters<typeof extractContractEventId>[0], receipt: ({
+    hash?: string;
+} & {
+    logs: Array<unknown>;
+}) | null, eventName: string, argName: string): string;

package/dist/shared/contracts.js

@@ -0,0 +1,46 @@
+import { Contract, JsonRpcProvider } from "ethers";
+import { generatedContractArtifacts } from "../generated/contracts.js";
+import { readEnvValue } from "./secrets.js";
+export async function loadArtifact(name) {
+    const artifact = generatedContractArtifacts[name];
+    return {
+        abi: artifact.abi,
+        bytecode: artifact.bytecode,
+        contractName: artifact.contractName,
+        sourceName: artifact.sourceName,
+    };
+}
+export async function getContract(name, address, runner) {
+    const artifact = await loadArtifact(name);
+    return new Contract(address, artifact.abi, runner);
+}
+export function getRpcUrl(env = process.env) {
+    return readEnvValue(env, "SP_RPC_URL") ?? "http://127.0.0.1:8545";
+}
+export function getProvider(rpcUrl = getRpcUrl()) {
+    return new JsonRpcProvider(rpcUrl);
+}
+export function extractContractEventId(contract, receipt, eventName, argName) {
+    for (const log of receipt.logs) {
+        try {
+            const parsed = contract.interface.parseLog(log);
+            if (parsed?.name === eventName) {
+                return parsed.args[argName].toString();
+            }
+        }
+        catch {
+            // Ignore unrelated logs.
+        }
+    }
+    return null;
+}
+export function requireContractEventId(contract, receipt, eventName, argName) {
+    if (!receipt) {
+        throw new Error(`missing transaction receipt for ${eventName}.${argName}`);
+    }
+    const value = extractContractEventId(contract, receipt, eventName, argName);
+    if (!value) {
+        throw new Error(`missing ${eventName}.${argName} in transaction ${receipt.hash ?? "unknown"}`);
+    }
+    return value;
+}

package/dist/shared/deployment.d.ts

@@ -0,0 +1,52 @@
+import { type EnvRecord } from "./secrets.js";
+export type DeploymentAddresses = {
+    accessController: string;
+    protocolParameters: string;
+    protocolGovernanceToken: string;
+    protocolTimelock: string;
+    protocolGovernor: string;
+    protocolTreasury: string;
+    resolutionModuleRegistry: string;
+    claimRegistry: string;
+    artifactRegistry: string;
+    bondEscrow: string;
+    claimRewardVault: string;
+    agentRegistry: string;
+    replicationRegistry: string;
+    reputationCheckpointRegistry: string;
+    epistemicMarket: string;
+    appealsRegistry: string;
+    computationalModule: string;
+    benchmarkModule: string;
+    wetLabModule: string;
+};
+export type DeploymentFile = {
+    network: string;
+    chainId: number;
+    deploymentBlock: number;
+    deployedAt: string;
+    addresses: DeploymentAddresses;
+};
+export declare const DEFAULT_DEPLOYMENT_PATH: string;
+export declare function getDeploymentPath(env?: EnvRecord): string;
+type DeploymentFileOptions = {
+    env?: EnvRecord;
+    gcsClient?: GcsLikeClient;
+};
+type GcsObjectLocator = {
+    bucket: string;
+    key: string;
+};
+type GcsLikeClient = {
+    saveObject(input: GcsObjectLocator & {
+        body?: string | Uint8Array;
+        contentType: string;
+        metadata?: Record<string, string>;
+    }): Promise<void>;
+    readObject(input: GcsObjectLocator): Promise<string | Uint8Array>;
+    objectExists(input: GcsObjectLocator): Promise<boolean>;
+};
+export declare function deploymentFileExists(filePath?: string, options?: DeploymentFileOptions): Promise<boolean>;
+export declare function loadDeploymentFile(filePath?: string, options?: DeploymentFileOptions): Promise<DeploymentFile>;
+export declare function saveDeploymentFile(deployment: DeploymentFile, filePath?: string, options?: DeploymentFileOptions): Promise<void>;
+export {};

package/dist/shared/deployment.js

@@ -0,0 +1,156 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { isAddress } from "ethers";
+import { readEnvValue } from "./secrets.js";
+export const DEFAULT_DEPLOYMENT_PATH = path.resolve(process.cwd(), "ops", "local.addresses.json");
+export function getDeploymentPath(env = process.env) {
+    return readEnvValue(env, "SP_DEPLOYMENT_PATH") ?? DEFAULT_DEPLOYMENT_PATH;
+}
+function isGcsUrl(value) {
+    return value.startsWith("gs://");
+}
+function parseGcsUrl(value) {
+    const match = value.match(/^gs:\/\/([^/]+)\/(.+)$/u);
+    if (!match) {
+        throw new Error(`invalid gcs path: ${value}`);
+    }
+    return { bucket: match[1], key: match[2] };
+}
+async function resolveDeploymentGcsClient(options) {
+    if (options.gcsClient) {
+        return options.gcsClient;
+    }
+    throw new Error("gs:// deployment paths require DeploymentFileOptions.gcsClient");
+}
+const DEPLOYMENT_ADDRESS_KEYS = [
+    "accessController",
+    "agentRegistry",
+    "appealsRegistry",
+    "artifactRegistry",
+    "benchmarkModule",
+    "bondEscrow",
+    "claimRegistry",
+    "claimRewardVault",
+    "computationalModule",
+    "epistemicMarket",
+    "protocolGovernor",
+    "protocolGovernanceToken",
+    "protocolParameters",
+    "protocolTimelock",
+    "protocolTreasury",
+    "replicationRegistry",
+    "reputationCheckpointRegistry",
+    "resolutionModuleRegistry",
+    "wetLabModule",
+];
+function recordLike(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function requireString(record, key, source) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`deployment file from ${source} is missing ${key}`);
+    }
+    return value;
+}
+function requireNonNegativeInteger(record, key, source) {
+    const value = record[key];
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`deployment file from ${source} has invalid ${key}`);
+    }
+    return value;
+}
+function requireTimestamp(record, key, source) {
+    const value = requireString(record, key, source);
+    if (Number.isNaN(Date.parse(value))) {
+        throw new Error(`deployment file from ${source} has invalid ${key}`);
+    }
+    return value;
+}
+function validateDeploymentFile(value, source) {
+    const record = recordLike(value);
+    if (!record) {
+        throw new Error(`deployment file from ${source} must be an object`);
+    }
+    const addresses = recordLike(record.addresses);
+    if (!addresses) {
+        throw new Error(`deployment file from ${source} is missing addresses`);
+    }
+    for (const key of DEPLOYMENT_ADDRESS_KEYS) {
+        const address = requireString(addresses, key, source);
+        if (!isAddress(address)) {
+            throw new Error(`deployment file from ${source} has invalid address for ${key}`);
+        }
+    }
+    return {
+        addresses: Object.fromEntries(DEPLOYMENT_ADDRESS_KEYS.map((key) => [key, addresses[key]])),
+        chainId: requireNonNegativeInteger(record, "chainId", source),
+        deployedAt: requireTimestamp(record, "deployedAt", source),
+        deploymentBlock: requireNonNegativeInteger(record, "deploymentBlock", source),
+        network: requireString(record, "network", source),
+    };
+}
+function parseDeploymentJson(raw, source) {
+    try {
+        return validateDeploymentFile(JSON.parse(raw), source);
+    }
+    catch (error) {
+        throw new Error(`failed to parse deployment file from ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function deploymentFileExists(filePath = DEFAULT_DEPLOYMENT_PATH, options = {}) {
+    const env = options.env ?? process.env;
+    const inline = readEnvValue(env, "SP_DEPLOYMENT_JSON");
+    if (inline) {
+        return true;
+    }
+    if (isGcsUrl(filePath)) {
+        const gcsClient = await resolveDeploymentGcsClient(options);
+        const locator = parseGcsUrl(filePath);
+        return gcsClient.objectExists(locator);
+    }
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function loadDeploymentFile(filePath = DEFAULT_DEPLOYMENT_PATH, options = {}) {
+    const env = options.env ?? process.env;
+    const inline = readEnvValue(env, "SP_DEPLOYMENT_JSON");
+    if (inline) {
+        return parseDeploymentJson(inline, "SP_DEPLOYMENT_JSON");
+    }
+    if (isGcsUrl(filePath)) {
+        const gcsClient = await resolveDeploymentGcsClient(options);
+        const locator = parseGcsUrl(filePath);
+        const object = await gcsClient.readObject(locator);
+        const content = typeof object === "string" ? object : new TextDecoder().decode(object);
+        return parseDeploymentJson(content, filePath);
+    }
+    return parseDeploymentJson(await readFile(filePath, "utf8"), filePath);
+}
+export async function saveDeploymentFile(deployment, filePath = DEFAULT_DEPLOYMENT_PATH, options = {}) {
+    const serialized = `${JSON.stringify(deployment, null, 2)}\n`;
+    if (isGcsUrl(filePath)) {
+        const gcsClient = await resolveDeploymentGcsClient(options);
+        const locator = parseGcsUrl(filePath);
+        await gcsClient.saveObject({
+            ...locator,
+            body: serialized,
+            contentType: "application/json",
+            metadata: {
+                chainId: String(deployment.chainId),
+                deploymentBlock: String(deployment.deploymentBlock),
+                network: deployment.network,
+            },
+        });
+        return;
+    }
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, serialized);
+}

package/dist/shared/secrets.d.ts

@@ -0,0 +1,6 @@
+export type EnvRecord = Record<string, string | undefined>;
+export declare function readEnvValue(env: EnvRecord, key: string, options?: {
+    trim?: boolean;
+}): string | undefined;
+export declare function hasConfiguredEnvValue(env: EnvRecord, key: string): boolean;
+export declare function hasSecretRef(env: EnvRecord, key: string): boolean;

package/dist/shared/secrets.js

@@ -0,0 +1,30 @@
+import { readFileSync } from "node:fs";
+function normalizeValue(value, trim) {
+    return trim ? value.trim() : value;
+}
+export function readEnvValue(env, key, options = {}) {
+    const trim = options.trim !== false;
+    const directValue = env[key];
+    if (typeof directValue === "string" && directValue.trim() !== "") {
+        return normalizeValue(directValue, trim);
+    }
+    const filePath = env[`${key}_FILE`]?.trim();
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        const fileValue = readFileSync(filePath, "utf8");
+        return normalizeValue(fileValue, trim);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to read ${key}_FILE (${filePath}): ${detail}`);
+    }
+}
+export function hasConfiguredEnvValue(env, key) {
+    return Boolean(readEnvValue(env, key) || hasSecretRef(env, key));
+}
+export function hasSecretRef(env, key) {
+    const secretRef = env[`${key}_SECRET_REF`];
+    return typeof secretRef === "string" && secretRef.trim() !== "";
+}

package/dist/shared/sha256.d.ts

@@ -0,0 +1,2 @@
+export type HashableContent = string | Uint8Array;
+export declare function sha256Hex(content: HashableContent): string;

package/dist/shared/sha256.js

@@ -0,0 +1,4 @@
+import { createHash } from "node:crypto";
+export function sha256Hex(content) {
+    return createHash("sha256").update(content).digest("hex");
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "scientific-protocol",
+  "version": "0.1.0",
+  "description": "Claim-centric protocol for scientific publication, replication, review, and reward.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emgun/scientific-protocol.git"
+  },
+  "bugs": {
+    "url": "https://github.com/emgun/scientific-protocol/issues"
+  },
+  "homepage": "https://github.com/emgun/scientific-protocol#readme",
+  "keywords": [
+    "science",
+    "ethereum",
+    "protocol",
+    "replication",
+    "reputation",
+    "solidity"
+  ],
+  "main": "./dist/sdk/index.js",
+  "types": "./dist/sdk/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/sdk/index.d.ts",
+      "import": "./dist/sdk/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/generated/contracts.d.ts",
+      "import": "./dist/generated/contracts.js"
+    },
+    "./schemas/claim": "./schemas/claim.schema.json",
+    "./schemas/replication": "./schemas/replication.schema.json",
+    "./schemas/evaluation": "./schemas/evaluation.schema.json",
+    "./schemas/artifact-storage-attestation": "./schemas/artifact-storage-attestation.schema.json",
+    "./schemas/artifact-storage-bundle": "./schemas/artifact-storage-bundle.schema.json"
+  },
+  "files": [
+    "dist",
+    "schemas",
+    "README.md"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22 <23"
+  },
+  "scripts": {
+    "build": "bash script/run-with-node22-env.sh hardhat clean && bash script/run-with-node22-env.sh hardhat compile && npm run generate:contracts",
+    "build:package": "npm run build && bash script/run-with-node22-env.sh tsc -p tsconfig.package.json",
+    "prepack": "npm run build:package",
+    "lint": "npm run lint:biome && npm run lint:prettier && npm run lint:shell",
+    "lint:biome": "bash script/run-with-node22-env.sh npx biome check --diagnostic-level=error --files-ignore-unknown=true src test script hardhat.config.ts package.json tsconfig.json biome.json .prettierrc.json",
+    "lint:prettier": "bash script/run-with-node22-env.sh prettier --check .",
+    "lint:shell": "bash -c 'for file in script/*.sh; do bash -n \"$file\"; done'",
+    "format": "npm run format:biome && npm run format:prettier",
+    "format:biome": "bash script/run-with-node22-env.sh npx biome check --write --files-ignore-unknown=true src test script hardhat.config.ts package.json tsconfig.json biome.json .prettierrc.json",
+    "format:prettier": "bash script/run-with-node22-env.sh prettier --write .",
+    "generate:contracts": "bash script/run-with-node22-env.sh node --import tsx script/generate-contract-artifacts.ts && bash script/run-with-node22-env.sh npx biome format --write src/generated/contracts.ts",
+    "typecheck": "bash script/run-with-node22-env.sh npx tsc --noEmit",
+    "test": "bash script/run-with-node22-env.sh hardhat test",
+    "test:forge": "forge test",
+    "test:all": "npm run test:forge && HOME=$PWD npm test",
+    "validate:env": "bash script/run-with-node22-env.sh node --import tsx script/validate-env.ts",
+    "node": "bash script/run-with-node22-env.sh hardhat node",
+    "node:env:init": "bash script/init-node22-env.sh",
+    "deploy": "bash script/run-with-node22-env.sh hardhat run --network localhost script/deploy-protocol.ts",
+    "gas:snapshot": "forge snapshot --snap .gas-snapshot",
+    "gas:check": "forge snapshot --check .gas-snapshot"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "^3.1011.0",
+    "@biomejs/biome": "^2.4.9",
+    "@google-cloud/storage": "^7.19.0",
+    "@nomicfoundation/hardhat-ethers": "^4.0.0",
+    "@nomicfoundation/hardhat-node-test-runner": "^3.0.11",
+    "@openzeppelin/contracts": "^4.9.6",
+    "@types/pg": "^8.11.10",
+    "chai": "^5.1.1",
+    "hardhat": "^3.1.12",
+    "pdf-parse": "^2.4.5",
+    "pg": "^8.13.1",
+    "prettier": "^3.8.1",
+    "prettier-plugin-solidity": "^2.3.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.4",
+    "typescript": "^5.5.4"
+  },
+  "overrides": {
+    "@tootallnate/once": "3.0.1",
+    "@actions/http-client": "2.2.3",
+    "@aws-sdk/xml-builder": "3.972.22",
+    "fast-xml-parser": "5.8.0",
+    "undici": "^6.24.0",
+    "ws": "8.21.0"
+  },
+  "dependencies": {
+    "ethers": "^6.13.2"
+  }
+}