scientific-protocol 0.1.0

package/dist/sdk/client.js

@@ -0,0 +1,427 @@
+export class ScientificProtocolApiError extends Error {
+    body;
+    response;
+    status;
+    constructor(response, body) {
+        super(`Scientific Protocol API request failed with status ${response.status}`);
+        this.name = "ScientificProtocolApiError";
+        this.status = response.status;
+        this.response = response;
+        this.body = body;
+    }
+}
+function trimTrailingSlash(input) {
+    return input.endsWith("/") ? input.slice(0, -1) : input;
+}
+function parseWorkItemId(itemId) {
+    const separator = itemId.indexOf(":");
+    if (separator <= 0 || separator === itemId.length - 1) {
+        throw new Error(`unsupported_work_item_id:${itemId}`);
+    }
+    return {
+        itemKey: itemId.slice(0, separator),
+        sourceId: itemId.slice(separator + 1),
+    };
+}
+function toSearchParams(query) {
+    if (!query) {
+        return "";
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined) {
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const serialized = params.toString();
+    return serialized ? `?${serialized}` : "";
+}
+async function parseResponseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        return response.json();
+    }
+    const text = await response.text();
+    return text.length > 0 ? text : null;
+}
+export class ScientificProtocolClient {
+    baseUrl;
+    demoAdminToken;
+    defaultHeaders;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = trimTrailingSlash(String(options.baseUrl));
+        this.demoAdminToken = options.demoAdminToken;
+        this.defaultHeaders = options.headers;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    demo = {
+        createClaim: (input) => this.request("/demo/claims", {
+            body: input,
+            method: "POST",
+        }),
+        enqueueArtifactAudits: (input = {}) => this.request("/demo/artifact-maintenance-tasks/enqueue-audits", {
+            body: input,
+            method: "POST",
+        }),
+        getAdminStatus: () => this.request("/demo/admin/status", {
+            admin: true,
+        }),
+        getScenarios: () => this.request("/demo/scenarios"),
+        openReplicationJob: (input) => this.request("/demo/replication-jobs", {
+            body: input,
+            method: "POST",
+        }),
+        openArtifactMaintenanceTask: (input) => this.request("/demo/artifact-maintenance-tasks", {
+            body: input,
+            method: "POST",
+        }),
+        processReplicationJob: (jobId, input = {}) => this.request(`/demo/replication-jobs/${jobId}/process`, {
+            body: input,
+            method: "POST",
+        }),
+        recomputeDomain: (domainId) => this.request(`/demo/domains/${domainId}/recompute`, {
+            body: {},
+            method: "POST",
+        }),
+        reseedOperational: () => this.request("/demo/admin/reseed-operational", {
+            admin: true,
+            body: {},
+            method: "POST",
+        }),
+        resetDemo: () => this.request("/demo/admin/reset-demo", {
+            admin: true,
+            body: {},
+            method: "POST",
+        }),
+        resolveReplicationJob: (jobId, input = {}) => this.request(`/demo/replication-jobs/${jobId}/resolve`, {
+            body: input,
+            method: "POST",
+        }),
+    };
+    production = {
+        createClaim: (signedRequest) => this.request("/claims", {
+            body: signedRequest,
+            method: "POST",
+        }),
+        createSource: (signedRequest) => this.request("/sources", {
+            body: signedRequest,
+            method: "POST",
+        }),
+        createClaimDraftFromArtifact: (signedRequest) => this.request("/claim-drafts/from-artifact", {
+            body: signedRequest,
+            method: "POST",
+        }),
+        confirmSourcePublication: (sourceId, signedRequest) => this.request(`/sources/${sourceId}/confirm`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        openReplicationJob: (claimId, signedRequest) => this.request(`/claims/${claimId}/replication-jobs`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        rejectSourcePublication: (sourceId, signedRequest) => this.request(`/sources/${sourceId}/reject`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        processReplicationJob: (jobId, signedRequest) => this.request(`/replication-jobs/${jobId}/process`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        recomputeDomain: (domainId, signedRequest) => this.request(`/domains/${domainId}/recompute`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        resolveReplicationJob: (jobId, signedRequest) => this.request(`/replication-jobs/${jobId}/resolve`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+    };
+    agent = {
+        claimArtifactMaintenanceTask: (taskId, signedRequest) => this.request(`/agent/artifact-maintenance-tasks/${taskId}/claim`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        heartbeatArtifactMaintenanceTask: (taskId, signedRequest) => this.request(`/agent/artifact-maintenance-tasks/${taskId}/heartbeat`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        submitArtifactAuditResults: (taskId, signedRequest) => this.request(`/agent/artifact-maintenance-tasks/${taskId}/audit-results`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        submitArtifactRepairResults: (taskId, signedRequest) => this.request(`/agent/artifact-maintenance-tasks/${taskId}/repair-results`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        claimReplicationJob: (jobId, signedRequest) => this.request(`/agent/replication-jobs/${jobId}/claim`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        heartbeatReplicationJob: (jobId, signedRequest) => this.request(`/agent/replication-jobs/${jobId}/heartbeat`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        submitReplicationResults: (jobId, signedRequest) => this.request(`/agent/replication-jobs/${jobId}/submissions`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        claimReviewTask: (taskId, signedRequest) => this.request(`/agent/review-tasks/${taskId}/claim`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        heartbeatReviewTask: (taskId, signedRequest) => this.request(`/agent/review-tasks/${taskId}/heartbeat`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        submitReviewResults: (taskId, signedRequest) => this.request(`/agent/review-tasks/${taskId}/submissions`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        submitSource: (signedRequest) => this.request("/agent/sources", {
+            body: signedRequest,
+            method: "POST",
+        }),
+        claimWorkItem: (itemId, signedRequest) => {
+            const parsed = parseWorkItemId(itemId);
+            if (parsed.itemKey === "review-task") {
+                return this.agent.claimReviewTask(parsed.sourceId, signedRequest);
+            }
+            if (parsed.itemKey === "artifact-maintenance") {
+                return this.agent.claimArtifactMaintenanceTask(parsed.sourceId, signedRequest);
+            }
+            if (parsed.itemKey === "replication-job") {
+                return this.agent.claimReplicationJob(parsed.sourceId, signedRequest);
+            }
+            throw new Error(`unsupported_claimable_work_item:${itemId}`);
+        },
+        heartbeatWorkItem: (itemId, signedRequest) => {
+            const parsed = parseWorkItemId(itemId);
+            if (parsed.itemKey === "review-task") {
+                return this.agent.heartbeatReviewTask(parsed.sourceId, signedRequest);
+            }
+            if (parsed.itemKey === "artifact-maintenance") {
+                return this.agent.heartbeatArtifactMaintenanceTask(parsed.sourceId, signedRequest);
+            }
+            if (parsed.itemKey === "replication-job") {
+                return this.agent.heartbeatReplicationJob(parsed.sourceId, signedRequest);
+            }
+            throw new Error(`unsupported_heartbeatable_work_item:${itemId}`);
+        },
+        submitWorkResults: (itemId, signedRequest) => {
+            const parsed = parseWorkItemId(itemId);
+            if (parsed.itemKey === "review-task") {
+                return this.agent.submitReviewResults(parsed.sourceId, signedRequest);
+            }
+            if (parsed.itemKey === "artifact-maintenance") {
+                if (signedRequest.envelope.actionType === "artifact_task_audit_submission") {
+                    return this.agent.submitArtifactAuditResults(parsed.sourceId, signedRequest);
+                }
+                if (signedRequest.envelope.actionType === "artifact_task_repair_submission") {
+                    return this.agent.submitArtifactRepairResults(parsed.sourceId, signedRequest);
+                }
+            }
+            if (parsed.itemKey === "replication-job") {
+                if (signedRequest.envelope.actionType === "replication_job_submission") {
+                    return this.agent.submitReplicationResults(parsed.sourceId, signedRequest);
+                }
+            }
+            throw new Error(`unsupported_work_result_submission:${itemId}:${signedRequest.envelope.actionType}`);
+        },
+        createWebhookSubscription: (signedRequest) => this.request("/agent/webhook-subscriptions", {
+            body: signedRequest,
+            method: "POST",
+        }),
+        deleteWebhookSubscription: (subscriptionId, signedRequest) => this.request(`/agent/webhook-subscriptions/${subscriptionId}/delete`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+        pingWebhookSubscription: (subscriptionId, signedRequest) => this.request(`/agent/webhook-subscriptions/${subscriptionId}/ping`, {
+            body: signedRequest,
+            method: "POST",
+        }),
+    };
+    async getAdminStatus() {
+        return this.request("/admin/status");
+    }
+    async getGovernance() {
+        return this.request("/governance");
+    }
+    async listGovernanceEvents(query) {
+        return this.request(`/governance/events${toSearchParams(query)}`);
+    }
+    async getGovernanceTreasury(query) {
+        return this.request(`/governance/treasury${toSearchParams(query)}`);
+    }
+    async getGovernanceProposal(proposalId, query) {
+        return this.request(`/governance/proposals/${proposalId}${toSearchParams(query)}`);
+    }
+    async listGovernanceProposals(query) {
+        return this.request(`/governance/proposals${toSearchParams(query)}`);
+    }
+    async getAgentRequest(requestId) {
+        return this.request(`/agent-requests/${requestId}`);
+    }
+    async getAgentReviewCalibration(agentId, query) {
+        return this.request(`/agents/${agentId}/review-calibration${toSearchParams(query)}`);
+    }
+    async getAgentWorkSummary(agentId, query) {
+        return this.request(`/agents/${agentId}/work-summary${toSearchParams(query)}`);
+    }
+    async getAgentRewards(agentId, query) {
+        return this.request(`/agents/${agentId}/rewards${toSearchParams(query)}`);
+    }
+    async getRewardSettlements(query) {
+        return this.request(`/reward-settlements${toSearchParams(query)}`);
+    }
+    async getRecipientRewards(recipient, query) {
+        return this.request(`/recipients/${recipient}/rewards${toSearchParams(query)}`);
+    }
+    async getRewardConfig() {
+        return this.request("/reward-config");
+    }
+    async getWriteConfig() {
+        return this.request("/write-config");
+    }
+    async getAgentRuntimeEvents(query) {
+        return this.request(`/agent-runtime/events${toSearchParams(query)}`);
+    }
+    async getAgentWebhookSubscription(subscriptionId) {
+        return this.request(`/agent-webhook-subscriptions/${subscriptionId}`);
+    }
+    async getAgentWebhookDelivery(deliveryId) {
+        return this.request(`/agent-webhook-deliveries/${deliveryId}`);
+    }
+    async getAgentWebhookSubscriptions(query) {
+        return this.request(`/agent-webhook-subscriptions${toSearchParams(query)}`);
+    }
+    async getAgentWebhookDeliveries(query) {
+        return this.request(`/agent-webhook-deliveries${toSearchParams(query)}`);
+    }
+    async getArtifactMaintenanceTask(taskId) {
+        return this.request(`/artifact-maintenance-tasks/${taskId}`);
+    }
+    async getCheckpointPublications(query) {
+        return this.request(`/checkpoint-publications${toSearchParams(query)}`);
+    }
+    async getClaim(claimId, options) {
+        return this.request(`/claims/${claimId}${toSearchParams({ view: options?.view })}`);
+    }
+    async getClaimReview(claimId) {
+        return this.request(`/claims/${claimId}/review`);
+    }
+    async getClaimRewards(claimId, query) {
+        return this.request(`/claims/${claimId}/rewards${toSearchParams(query)}`);
+    }
+    async getClaimWorkGraph(claimId) {
+        return this.request(`/claims/${claimId}/work-graph`);
+    }
+    async getWorkItem(itemId, query) {
+        return this.request(`/work-items/${encodeURIComponent(itemId)}${toSearchParams(query)}`);
+    }
+    async getDomainLeaderboard(domainId, query) {
+        return this.request(`/domains/${domainId}/leaderboard${toSearchParams(query)}`);
+    }
+    async getHealth() {
+        return this.request("/health");
+    }
+    async getReviewTask(taskId) {
+        return this.request(`/review-tasks/${taskId}`);
+    }
+    async getSource(sourceId) {
+        return this.request(`/sources/${sourceId}`);
+    }
+    async getSourcePublicationDecisions(sourceId, query) {
+        return this.request(`/sources/${sourceId}/publication-decisions${toSearchParams(query)}`);
+    }
+    async getSourceWorkGraph(sourceId) {
+        return this.request(`/sources/${sourceId}/work-graph`);
+    }
+    async listSourceFeed(query) {
+        return this.request(`/feeds/sources${toSearchParams(query)}`);
+    }
+    async listClaimFeed(query) {
+        return this.request(`/feeds/claims${toSearchParams(query)}`);
+    }
+    async listSourceEvents(query) {
+        return this.request(`/events/sources${toSearchParams(query)}`);
+    }
+    async listClaimEvents(query) {
+        return this.request(`/events/claims${toSearchParams(query)}`);
+    }
+    async getOperatorRequests(query) {
+        return this.request(`/operator-requests${toSearchParams(query)}`);
+    }
+    async getReplicationJob(jobId) {
+        return this.request(`/replication-jobs/${jobId}`);
+    }
+    async getPersistedArtifact(artifactKey) {
+        return this.request(`/persisted-artifacts/${encodeURIComponent(artifactKey)}`);
+    }
+    getPersistedArtifactContentUrl(artifactKey) {
+        return `${this.baseUrl}/persisted-artifacts/${encodeURIComponent(artifactKey)}/content`;
+    }
+    async getPersistedArtifactAudits(artifactKey, query) {
+        return this.request(`/persisted-artifacts/${encodeURIComponent(artifactKey)}/audits${toSearchParams(query)}`);
+    }
+    async getPersistedArtifactMaintenanceTasks(artifactKey, query) {
+        return this.request(`/persisted-artifacts/${encodeURIComponent(artifactKey)}/maintenance-tasks${toSearchParams(query)}`);
+    }
+    async getResolutionRun(runId) {
+        return this.request(`/resolution-runs/${runId}`);
+    }
+    async listClaims(query) {
+        return this.request(`/claims${toSearchParams(query)}`);
+    }
+    async listReplications(query) {
+        return this.request(`/replications${toSearchParams(query)}`);
+    }
+    async listCheckpoints(query) {
+        return this.request(`/checkpoints${toSearchParams(query)}`);
+    }
+    async listArtifactMaintenanceTasks(query) {
+        return this.request(`/artifact-maintenance-tasks${toSearchParams(query)}`);
+    }
+    async listReviewTasks(query) {
+        return this.request(`/review-tasks${toSearchParams(query)}`);
+    }
+    async listSources(query) {
+        return this.request(`/sources${toSearchParams(query)}`);
+    }
+    async listWorkItems(query) {
+        return this.request(`/work-items${toSearchParams(query)}`);
+    }
+    async listAgentRequests(query) {
+        return this.request(`/agent-requests${toSearchParams(query)}`);
+    }
+    async listScenarios() {
+        return this.demo.getScenarios();
+    }
+    async request(pathname, init = {}) {
+        const headers = new Headers(this.defaultHeaders);
+        if (init.headers) {
+            const extraHeaders = new Headers(init.headers);
+            for (const [key, value] of extraHeaders.entries()) {
+                headers.set(key, value);
+            }
+        }
+        if (init.body !== undefined && !headers.has("content-type")) {
+            headers.set("content-type", "application/json");
+        }
+        if (init.admin && this.demoAdminToken) {
+            headers.set("authorization", `Bearer ${this.demoAdminToken}`);
+            headers.set("x-sp-demo-admin-token", this.demoAdminToken);
+        }
+        const response = await this.fetchImpl(`${this.baseUrl}${pathname}`, {
+            body: init.body === undefined ? undefined : JSON.stringify(init.body),
+            headers,
+            method: init.method ?? "GET",
+        });
+        const body = await parseResponseBody(response);
+        if (!response.ok) {
+            throw new ScientificProtocolApiError(response, body);
+        }
+        return body;
+    }
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,8 @@
+export { coreProtocolContractArtifacts, deployableContractArtifacts, generatedContractArtifacts, resolutionModuleContractArtifacts, } from "../generated/contracts.js";
+export { type AgentRequestActionType, type AgentRequestEnvelope, type AgentRequestSigner, createSignedAgentRequest, hashAgentRequestEnvelope, type SignedAgentRequestEnvelope, signAgentRequestEnvelope, verifyAgentRequestEnvelope, } from "../shared/agent-request-envelope.js";
+export { type ArtifactStorageAttestationActionType, type ArtifactStorageAttestationEnvelope, type ArtifactStorageAttestationSigner, buildArtifactStorageAttestationEnvelope, buildArtifactStorageAttestationScopeKey, createSignedArtifactStorageAttestation, hashArtifactStorageAttestationEnvelope, type SignedArtifactStorageAttestation, signArtifactStorageAttestation, toArtifactStorageAttestationRecordInput, type VerifiedArtifactStorageAttestation, verifyArtifactStorageAttestation, } from "../shared/artifact-storage-attestations.js";
+export { type ArtifactStorageBundleManifest, type ArtifactStorageBundleManifestArtifact, type ArtifactStorageBundleManifestArtifactInput, type ArtifactStorageBundleManifestInput, type ArtifactStorageBundlePolicyInput, buildArtifactStorageBundleManifest, createArtifactStorageBundlePolicyInputs, verifyArtifactStorageBundleManifest, } from "../shared/artifact-storage-bundles.js";
+export { ARTIFACT_STORAGE_CLASS_POLICIES, type ArtifactDurabilityClass, type ArtifactStorageAttestationInput, type ArtifactStorageClassPolicy, type ArtifactStorageCommitmentKind, type ArtifactStoragePolicyInput, defaultArtifactStoragePolicy, resolveArtifactStoragePolicyInput, } from "../shared/artifact-storage-policy.js";
+export { ScientificProtocolApiError, ScientificProtocolClient, type ScientificProtocolClientOptions, } from "./client.js";
+export { claimRewardWorkKindCode, type FundClaimRewardPoolInput, fundClaimRewardPool, fundClaimRewardPoolWithContract, getClaimRewardVaultContract, type RewardContractOptions, resolveRewardAmountWei, type WithdrawAccruedRewardsInput, withdrawAccruedRewards, withdrawAccruedRewardsWithContract, } from "./rewards.js";
+export type * from "./types.js";

package/dist/sdk/index.js

@@ -0,0 +1,7 @@
+export { coreProtocolContractArtifacts, deployableContractArtifacts, generatedContractArtifacts, resolutionModuleContractArtifacts, } from "../generated/contracts.js";
+export { createSignedAgentRequest, hashAgentRequestEnvelope, signAgentRequestEnvelope, verifyAgentRequestEnvelope, } from "../shared/agent-request-envelope.js";
+export { buildArtifactStorageAttestationEnvelope, buildArtifactStorageAttestationScopeKey, createSignedArtifactStorageAttestation, hashArtifactStorageAttestationEnvelope, signArtifactStorageAttestation, toArtifactStorageAttestationRecordInput, verifyArtifactStorageAttestation, } from "../shared/artifact-storage-attestations.js";
+export { buildArtifactStorageBundleManifest, createArtifactStorageBundlePolicyInputs, verifyArtifactStorageBundleManifest, } from "../shared/artifact-storage-bundles.js";
+export { ARTIFACT_STORAGE_CLASS_POLICIES, defaultArtifactStoragePolicy, resolveArtifactStoragePolicyInput, } from "../shared/artifact-storage-policy.js";
+export { ScientificProtocolApiError, ScientificProtocolClient, } from "./client.js";
+export { claimRewardWorkKindCode, fundClaimRewardPool, fundClaimRewardPoolWithContract, getClaimRewardVaultContract, resolveRewardAmountWei, withdrawAccruedRewards, withdrawAccruedRewardsWithContract, } from "./rewards.js";

package/dist/sdk/rewards.d.ts

@@ -0,0 +1,42 @@
+import { type ContractRunner } from "ethers";
+import { getContract } from "../shared/contracts.js";
+export type ClaimRewardWorkKind = "challenge" | "forecast" | "maintenance" | "replication" | "review" | "synthesis";
+type RewardAmountInput = {
+    amountEth?: string;
+    amountWei?: string;
+};
+type ClaimRewardVaultFundingContract = {
+    fundClaimRewards(claimId: bigint, workKind: number, overrides: {
+        value: bigint;
+    }): Promise<unknown>;
+};
+type ClaimRewardVaultWithdrawalContract = {
+    withdrawAccruedRewards(amount: bigint, recipient: string): Promise<unknown>;
+};
+export type RewardContractOptions = {
+    deploymentPath?: string;
+    runner: ContractRunner;
+};
+export type FundClaimRewardPoolInput = RewardAmountInput & RewardContractOptions & {
+    claimId: bigint | number | string;
+    workKind: ClaimRewardWorkKind;
+};
+export type WithdrawAccruedRewardsInput = RewardAmountInput & RewardContractOptions & {
+    recipient: string;
+};
+export declare function claimRewardWorkKindCode(workKind: ClaimRewardWorkKind): number;
+export declare function parseClaimRewardWorkKind(workKind: string): ClaimRewardWorkKind;
+export declare function resolveRewardAmountWei(input: RewardAmountInput): bigint;
+export declare function getClaimRewardVaultContract(options: RewardContractOptions): Promise<Awaited<ReturnType<typeof getContract>> & ClaimRewardVaultFundingContract & ClaimRewardVaultWithdrawalContract>;
+export declare function fundClaimRewardPoolWithContract(contract: ClaimRewardVaultFundingContract, input: {
+    amountWei: bigint;
+    claimId: bigint | number | string;
+    workKind: ClaimRewardWorkKind;
+}): Promise<unknown>;
+export declare function withdrawAccruedRewardsWithContract(contract: ClaimRewardVaultWithdrawalContract, input: {
+    amountWei: bigint;
+    recipient: string;
+}): Promise<unknown>;
+export declare function fundClaimRewardPool(input: FundClaimRewardPoolInput): Promise<unknown>;
+export declare function withdrawAccruedRewards(input: WithdrawAccruedRewardsInput): Promise<unknown>;
+export {};

package/dist/sdk/rewards.js

@@ -0,0 +1,84 @@
+import { parseEther } from "ethers";
+import { getContract } from "../shared/contracts.js";
+import { DEFAULT_DEPLOYMENT_PATH, loadDeploymentFile } from "../shared/deployment.js";
+const CLAIM_REWARD_WORK_KIND_CODES = {
+    challenge: 3,
+    forecast: 5,
+    maintenance: 2,
+    replication: 1,
+    review: 0,
+    synthesis: 4,
+};
+export function claimRewardWorkKindCode(workKind) {
+    return CLAIM_REWARD_WORK_KIND_CODES[parseClaimRewardWorkKind(String(workKind))];
+}
+export function parseClaimRewardWorkKind(workKind) {
+    if (workKind in CLAIM_REWARD_WORK_KIND_CODES) {
+        return workKind;
+    }
+    throw new Error(`unsupported reward work kind: ${workKind}`);
+}
+export function resolveRewardAmountWei(input) {
+    let amount;
+    if (typeof input.amountWei === "string") {
+        const trimmed = input.amountWei.trim();
+        if (trimmed.length === 0) {
+            throw new Error("amountWei cannot be empty");
+        }
+        try {
+            amount = BigInt(trimmed);
+        }
+        catch {
+            throw new Error("amountWei must be an integer wei amount");
+        }
+    }
+    else if (typeof input.amountEth === "string") {
+        const trimmed = input.amountEth.trim();
+        if (trimmed.length === 0) {
+            throw new Error("amountEth cannot be empty");
+        }
+        try {
+            amount = parseEther(trimmed);
+        }
+        catch {
+            throw new Error("amountEth must be a decimal ETH amount");
+        }
+    }
+    else {
+        throw new Error("set amountWei or amountEth");
+    }
+    if (amount <= 0n) {
+        throw new Error("reward amount must be greater than zero");
+    }
+    return amount;
+}
+export async function getClaimRewardVaultContract(options) {
+    const deployment = await loadDeploymentFile(options.deploymentPath ?? DEFAULT_DEPLOYMENT_PATH);
+    return (await getContract("ClaimRewardVault", deployment.addresses.claimRewardVault, options.runner));
+}
+export async function fundClaimRewardPoolWithContract(contract, input) {
+    return contract.fundClaimRewards(BigInt(input.claimId), claimRewardWorkKindCode(input.workKind), {
+        value: input.amountWei,
+    });
+}
+export async function withdrawAccruedRewardsWithContract(contract, input) {
+    return contract.withdrawAccruedRewards(input.amountWei, input.recipient);
+}
+export async function fundClaimRewardPool(input) {
+    const amountWei = resolveRewardAmountWei(input);
+    const workKind = parseClaimRewardWorkKind(input.workKind);
+    const contract = await getClaimRewardVaultContract(input);
+    return fundClaimRewardPoolWithContract(contract, {
+        amountWei,
+        claimId: input.claimId,
+        workKind,
+    });
+}
+export async function withdrawAccruedRewards(input) {
+    const amountWei = resolveRewardAmountWei(input);
+    const contract = await getClaimRewardVaultContract(input);
+    return withdrawAccruedRewardsWithContract(contract, {
+        amountWei,
+        recipient: input.recipient,
+    });
+}