@arc402/sdk 0.2.0

package/dist/watchtower.d.ts

@@ -0,0 +1,60 @@
+import { ContractRunner } from "ethers";
+import type { ChannelState } from "./types";
+import { ChannelClient } from "./channel";
+export interface WatchtowerMetadata {
+    name: string;
+    description: string;
+    capabilities: string[];
+}
+export interface WatchtowerStatus {
+    addr: string;
+    name: string;
+    description: string;
+    capabilities: string[];
+    active: boolean;
+    registeredAt: number;
+}
+export declare class WatchtowerClient {
+    private registry;
+    private channelContract;
+    private signer;
+    private _channelClient;
+    constructor(registryAddress: string, channelContractAddress: string, runner: ContractRunner);
+    /**
+     * Register this node as a watchtower in the WatchtowerRegistry.
+     */
+    registerWatchtower(metadata: WatchtowerMetadata): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Submit a watchtower challenge on behalf of `beneficiary`.
+     * The `state` must be a doubly-signed ChannelState with a higher sequenceNumber
+     * than the one currently recorded on-chain.
+     */
+    submitChallenge(channelId: string, state: ChannelState, beneficiary: string): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Get the on-chain registration status of a watchtower address.
+     */
+    getWatchtowerStatus(watchtowerAddress: string): Promise<WatchtowerStatus>;
+    /**
+     * Authorize a watchtower to challenge on your behalf for a specific channel.
+     */
+    authorizeWatchtower(channelId: string, watchtower: string): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Revoke a watchtower's authorization for a channel.
+     */
+    revokeWatchtower(channelId: string, watchtower: string): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Check whether a watchtower is authorized for a channel.
+     */
+    isWatchtowerAuthorized(channelId: string, watchtower: string): Promise<boolean>;
+    /** Expose ChannelClient for polling in watch loops. */
+    get channelClient(): ChannelClient;
+}
+//# sourceMappingURL=watchtower.d.ts.map

package/dist/watchtower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchtower.d.ts","sourceRoot":"","sources":["../src/watchtower.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,cAAc,EAAU,MAAM,QAAQ,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAgB1C,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,cAAc,CAAgB;gBAGpC,eAAe,EAAE,MAAM,EACvB,sBAAsB,EAAE,MAAM,EAC9B,MAAM,EAAE,cAAc;IAQxB;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAOnF;;;;OAIG;IACG,eAAe,CACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAQ9B;;OAEG;IACG,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAY/E;;OAEG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAO7F;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAO1F;;OAEG;IACG,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrF,uDAAuD;IACvD,IAAI,aAAa,IAAI,aAAa,CAEjC;CACF"}

package/dist/watchtower.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchtowerClient = void 0;
+const ethers_1 = require("ethers");
+const channel_1 = require("./channel");
+const WATCHTOWER_REGISTRY_ABI = [
+    "function register(string name, string description, string[] capabilities) external",
+    "function getWatchtower(address watchtower) external view returns (tuple(address addr, string name, string description, string[] capabilities, bool active, uint256 registeredAt))",
+    "function isRegistered(address watchtower) external view returns (bool)",
+    "event WatchtowerRegistered(address indexed watchtower, string name)",
+];
+const SESSION_CHANNEL_WATCHTOWER_ABI = [
+    "function authorizeWatchtower(bytes32 channelId, address watchtower) external",
+    "function revokeWatchtower(bytes32 channelId, address watchtower) external",
+    "function submitWatchtowerChallenge(bytes32 channelId, bytes latestState, address beneficiary) external",
+    "function isWatchtowerAuthorized(bytes32 channelId, address watchtower) external view returns (bool)",
+];
+class WatchtowerClient {
+    constructor(registryAddress, channelContractAddress, runner) {
+        this.registry = new ethers_1.ethers.Contract(registryAddress, WATCHTOWER_REGISTRY_ABI, runner);
+        this.channelContract = new ethers_1.ethers.Contract(channelContractAddress, SESSION_CHANNEL_WATCHTOWER_ABI, runner);
+        this.signer = runner instanceof ethers_1.AbstractSigner ? runner : null;
+        this._channelClient = new channel_1.ChannelClient(channelContractAddress, runner);
+    }
+    /**
+     * Register this node as a watchtower in the WatchtowerRegistry.
+     */
+    async registerWatchtower(metadata) {
+        if (!this.signer)
+            throw new Error("Signer required");
+        const tx = await this.registry.register(metadata.name, metadata.description, metadata.capabilities);
+        const receipt = await tx.wait();
+        return { txHash: receipt.hash };
+    }
+    /**
+     * Submit a watchtower challenge on behalf of `beneficiary`.
+     * The `state` must be a doubly-signed ChannelState with a higher sequenceNumber
+     * than the one currently recorded on-chain.
+     */
+    async submitChallenge(channelId, state, beneficiary) {
+        if (!this.signer)
+            throw new Error("Signer required");
+        const encoded = this._channelClient.encodeChannelState(state);
+        const tx = await this.channelContract.submitWatchtowerChallenge(channelId, encoded, beneficiary);
+        const receipt = await tx.wait();
+        return { txHash: receipt.hash };
+    }
+    /**
+     * Get the on-chain registration status of a watchtower address.
+     */
+    async getWatchtowerStatus(watchtowerAddress) {
+        const raw = await this.registry.getWatchtower(watchtowerAddress);
+        return {
+            addr: raw.addr,
+            name: raw.name,
+            description: raw.description,
+            capabilities: [...raw.capabilities],
+            active: raw.active,
+            registeredAt: Number(raw.registeredAt),
+        };
+    }
+    /**
+     * Authorize a watchtower to challenge on your behalf for a specific channel.
+     */
+    async authorizeWatchtower(channelId, watchtower) {
+        if (!this.signer)
+            throw new Error("Signer required");
+        const tx = await this.channelContract.authorizeWatchtower(channelId, watchtower);
+        const receipt = await tx.wait();
+        return { txHash: receipt.hash };
+    }
+    /**
+     * Revoke a watchtower's authorization for a channel.
+     */
+    async revokeWatchtower(channelId, watchtower) {
+        if (!this.signer)
+            throw new Error("Signer required");
+        const tx = await this.channelContract.revokeWatchtower(channelId, watchtower);
+        const receipt = await tx.wait();
+        return { txHash: receipt.hash };
+    }
+    /**
+     * Check whether a watchtower is authorized for a channel.
+     */
+    async isWatchtowerAuthorized(channelId, watchtower) {
+        return this.channelContract.isWatchtowerAuthorized(channelId, watchtower);
+    }
+    /** Expose ChannelClient for polling in watch loops. */
+    get channelClient() {
+        return this._channelClient;
+    }
+}
+exports.WatchtowerClient = WatchtowerClient;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@arc402/sdk",
+  "version": "0.2.0",
+  "description": "ARC-402 typed TypeScript SDK for discovery, negotiation, trust, and governed settlement",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/LegoGigaBrain/arc-402",
+  "license": "MIT",
+  "keywords": [
+    "arc402",
+    "web3",
+    "agents",
+    "wallet",
+    "governance",
+    "blockchain"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test test/**/*.test.js"
+  },
+  "dependencies": {
+    "ethers": "^6.9.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/agent.ts

@@ -0,0 +1,122 @@
+import { ContractRunner } from "ethers";
+import { AGENT_REGISTRY_ABI } from "./contracts";
+import { ethers } from "ethers";
+import { AgentInfo, OperationalMetrics } from "./types";
+
+export interface AgentRegistrationInput {
+  name: string;
+  capabilities: string[];
+  serviceType: string;
+  endpoint: string;
+  metadataURI?: string;
+}
+
+export class AgentRegistryClient {
+  private contract: ethers.Contract;
+
+  constructor(address: string, runner: ContractRunner) {
+    this.contract = new ethers.Contract(address, AGENT_REGISTRY_ABI, runner);
+  }
+
+  async register(input: AgentRegistrationInput) {
+    const tx = await this.contract.register(input.name, input.capabilities, input.serviceType, input.endpoint, input.metadataURI ?? "");
+    return tx.wait();
+  }
+
+  async update(input: AgentRegistrationInput) {
+    const tx = await this.contract.update(input.name, input.capabilities, input.serviceType, input.endpoint, input.metadataURI ?? "");
+    return tx.wait();
+  }
+
+  async deactivate() { const tx = await this.contract.deactivate(); return tx.wait(); }
+  async reactivate() { const tx = await this.contract.reactivate(); return tx.wait(); }
+  async submitHeartbeat(latencyMs: number) { const tx = await this.contract.submitHeartbeat(latencyMs); return tx.wait(); }
+  async setHeartbeatPolicy(intervalSeconds: number, gracePeriodSeconds: number) {
+    const tx = await this.contract.setHeartbeatPolicy(intervalSeconds, gracePeriodSeconds);
+    return tx.wait();
+  }
+
+  async getAgent(wallet: string): Promise<AgentInfo> {
+    const [raw, trustScore] = await Promise.all([this.contract.getAgent(wallet), this.contract.getTrustScore(wallet)]);
+    return {
+      wallet: raw.wallet,
+      name: raw.name,
+      capabilities: [...raw.capabilities],
+      serviceType: raw.serviceType,
+      endpoint: raw.endpoint,
+      metadataURI: raw.metadataURI,
+      active: raw.active,
+      registeredAt: BigInt(raw.registeredAt),
+      endpointChangedAt: BigInt(raw.endpointChangedAt),
+      endpointChangeCount: BigInt(raw.endpointChangeCount),
+      trustScore: BigInt(trustScore),
+    };
+  }
+
+  async getOperationalMetrics(wallet: string): Promise<OperationalMetrics> {
+    const raw = await this.contract.getOperationalMetrics(wallet);
+    return {
+      heartbeatInterval: BigInt(raw.heartbeatInterval),
+      heartbeatGracePeriod: BigInt(raw.heartbeatGracePeriod),
+      lastHeartbeatAt: BigInt(raw.lastHeartbeatAt),
+      rollingLatency: BigInt(raw.rollingLatency),
+      heartbeatCount: BigInt(raw.heartbeatCount),
+      missedHeartbeatCount: BigInt(raw.missedHeartbeatCount),
+      uptimeScore: BigInt(raw.uptimeScore),
+      responseScore: BigInt(raw.responseScore),
+    };
+  }
+
+  async listAgents(limit?: number): Promise<AgentInfo[]> {
+    const count = Number(await this.contract.agentCount());
+    const end = limit ? Math.min(limit, count) : count;
+    const addresses = await Promise.all(Array.from({ length: end }, (_, i) => this.contract.getAgentAtIndex(i)));
+    return Promise.all(addresses.map((address: string) => this.getAgent(address)));
+  }
+
+  async findByCapability(capability: string, limit?: number): Promise<AgentInfo[]> {
+    const agents = await this.listAgents(limit);
+    return agents.filter((agent) => agent.capabilities.includes(capability));
+  }
+
+  async searchByCapability(capability: string): Promise<AgentInfo[]> {
+    const agents = await this.listAgents();
+    return agents.filter(
+      (agent) => agent.active && agent.capabilities.some((c) => c === capability || c.startsWith(capability + "."))
+    );
+  }
+
+  async searchByServiceType(serviceType: string): Promise<AgentInfo[]> {
+    const agents = await this.listAgents();
+    const query = serviceType.toLowerCase();
+    return agents.filter(
+      (agent) => agent.active && agent.serviceType.toLowerCase().includes(query)
+    );
+  }
+
+  async searchByName(query: string): Promise<AgentInfo[]> {
+    const agents = await this.listAgents();
+    const lower = query.toLowerCase();
+    return agents.filter(
+      (agent) => agent.active && agent.name.toLowerCase().includes(lower)
+    );
+  }
+
+  async getTopByTrust(limit = 20): Promise<AgentInfo[]> {
+    const agents = await this.listAgents();
+    return agents
+      .filter((agent) => agent.active)
+      .sort((a, b) => {
+        const aScore = BigInt(a.trustScore ?? 0n);
+        const bScore = BigInt(b.trustScore ?? 0n);
+        return bScore > aScore ? 1 : bScore < aScore ? -1 : 0;
+      })
+      .slice(0, limit);
+  }
+
+  async getActive(limit?: number): Promise<AgentInfo[]> {
+    const agents = await this.listAgents();
+    const active = agents.filter((agent) => agent.active);
+    return limit ? active.slice(0, limit) : active;
+  }
+}

package/src/agreement.ts

@@ -0,0 +1,236 @@
+import { ContractRunner, ethers } from "ethers";
+import { SERVICE_AGREEMENT_ABI } from "./contracts";
+import {
+  Agreement,
+  AgreementStatus,
+  ArbitrationCase,
+  ArbitrationVote,
+  DisputeCase,
+  DisputeClass,
+  DisputeEvidence,
+  DisputeMode,
+  DisputeOutcome,
+  DirectDisputeReason,
+  EvidenceType,
+  ProposeParams,
+  ProviderResponseType,
+  RemediationCase,
+  RemediationFeedback,
+  RemediationResponse,
+} from "./types";
+
+export class ServiceAgreementClient {
+  private contract: ethers.Contract;
+
+  constructor(address: string, runner: ContractRunner) {
+    this.contract = new ethers.Contract(address, SERVICE_AGREEMENT_ABI, runner);
+  }
+
+  async propose(params: ProposeParams): Promise<{ agreementId: bigint; receipt: ethers.TransactionReceipt }> {
+    const isEth = params.token === ethers.ZeroAddress;
+    const tx = await this.contract.propose(
+      params.provider,
+      params.serviceType,
+      params.description,
+      params.price,
+      params.token,
+      params.deadline,
+      params.deliverablesHash,
+      { value: isEth ? params.price : 0n },
+    );
+    const receipt = await tx.wait();
+    const iface = new ethers.Interface(SERVICE_AGREEMENT_ABI);
+    for (const log of receipt.logs) {
+      try {
+        const parsed = iface.parseLog(log);
+        if (parsed?.name === "AgreementProposed") return { agreementId: BigInt(parsed.args.id), receipt };
+      } catch {}
+    }
+    throw new Error("Could not parse AgreementProposed event");
+  }
+
+  async accept(id: bigint) { const tx = await this.contract.accept(id); return tx.wait(); }
+  /** @deprecated Legacy/trusted-only immediate release path. Prefer commitDeliverable() + verifyDeliverable()/autoRelease(). */
+  async fulfill(id: bigint, hash: string) { const tx = await this.contract.fulfill(id, hash); return tx.wait(); }
+  async fulfillLegacyTrustedOnly(id: bigint, hash: string) { return this.fulfill(id, hash); }
+  async commitDeliverable(id: bigint, hash: string) { const tx = await this.contract.commitDeliverable(id, hash); return tx.wait(); }
+  async verifyDeliverable(id: bigint) { const tx = await this.contract.verifyDeliverable(id); return tx.wait(); }
+  async autoRelease(id: bigint) { const tx = await this.contract.autoRelease(id); return tx.wait(); }
+  async dispute(id: bigint, reason: string, feeEth = 0n) { const tx = await this.contract.dispute(id, reason, { value: feeEth }); return tx.wait(); }
+  async directDispute(id: bigint, directReason: DirectDisputeReason, reason: string, feeEth = 0n) { const tx = await this.contract.directDispute(id, directReason, reason, { value: feeEth }); return tx.wait(); }
+  async escalateToDispute(id: bigint, reason: string, feeEth = 0n) { const tx = await this.contract.escalateToDispute(id, reason, { value: feeEth }); return tx.wait(); }
+
+  /** Open a dispute with explicit mode and class. For ETH agreements, pass fee as feeEth. */
+  async openDisputeWithMode(
+    id: bigint,
+    mode: DisputeMode,
+    disputeClass: DisputeClass,
+    reason: string,
+    feeEth = 0n
+  ): Promise<ethers.TransactionReceipt> {
+    const tx = await this.contract.openDisputeWithMode(id, mode, disputeClass, reason, { value: feeEth });
+    return tx.wait();
+  }
+
+  /** Shorthand: UNILATERAL dispute with specified class. */
+  async openUnilateralDispute(
+    id: bigint,
+    disputeClass: DisputeClass,
+    reason: string,
+    feeEth = 0n
+  ): Promise<ethers.TransactionReceipt> {
+    return this.openDisputeWithMode(id, DisputeMode.UNILATERAL, disputeClass, reason, feeEth);
+  }
+
+  /** Shorthand: MUTUAL dispute — opener pays half. Respondent calls DisputeArbitrationClient.joinMutualDispute(). */
+  async openMutualDispute(
+    id: bigint,
+    disputeClass: DisputeClass,
+    reason: string,
+    halfFeeEth = 0n
+  ): Promise<ethers.TransactionReceipt> {
+    return this.openDisputeWithMode(id, DisputeMode.MUTUAL, disputeClass, reason, halfFeeEth);
+  }
+  async canDirectDispute(id: bigint, directReason: DirectDisputeReason): Promise<boolean> { return this.contract.canDirectDispute(id, directReason); }
+  async cancel(id: bigint) { const tx = await this.contract.cancel(id); return tx.wait(); }
+  async expiredCancel(id: bigint) { const tx = await this.contract.expiredCancel(id); return tx.wait(); }
+  async resolveDisputeDetailed(id: bigint, outcome: DisputeOutcome, providerAward: bigint, clientAward: bigint) {
+    const tx = await this.contract.resolveDisputeDetailed(id, outcome, providerAward, clientAward); return tx.wait();
+  }
+
+  /** Owner-only: resolve a dispute directly in favor of provider or client. Requires DISPUTED or ESCALATED_TO_HUMAN status. */
+  async ownerResolveDispute(agreementId: bigint, favorProvider: boolean): Promise<ethers.TransactionReceipt> {
+    const tx = await this.contract.ownerResolveDispute(agreementId, favorProvider);
+    return tx.wait();
+  }
+
+  /**
+   * Called by the DisputeArbitration contract to resolve a dispute with split amounts.
+   * @param agreementId Agreement to resolve
+   * @param recipient  Address of the winning party
+   * @param providerAmount Provider payout in token units
+   * @param clientAmount   Client refund in token units
+   */
+  async resolveFromArbitration(
+    agreementId: bigint,
+    recipient: string,
+    providerAmount: bigint,
+    clientAmount: bigint,
+  ): Promise<ethers.TransactionReceipt> {
+    const tx = await this.contract.resolveFromArbitration(agreementId, recipient, providerAmount, clientAmount);
+    return tx.wait();
+  }
+
+  async requestRevision(agreementId: bigint, feedbackHash: string, feedbackURI = "", previousTranscriptHash = ethers.ZeroHash) {
+    const tx = await this.contract.requestRevision(agreementId, feedbackHash, feedbackURI, previousTranscriptHash);
+    return tx.wait();
+  }
+
+  async respondToRevision(
+    agreementId: bigint,
+    responseType: ProviderResponseType,
+    responseHash: string,
+    responseURI = "",
+    previousTranscriptHash = ethers.ZeroHash,
+    proposedProviderPayout = 0n,
+  ) {
+    const tx = await this.contract.respondToRevision(
+      agreementId,
+      responseType,
+      proposedProviderPayout,
+      responseHash,
+      responseURI,
+      previousTranscriptHash,
+    );
+    return tx.wait();
+  }
+
+  async submitDisputeEvidence(agreementId: bigint, evidenceType: EvidenceType, evidenceHash: string, evidenceURI = "") {
+    const tx = await this.contract.submitDisputeEvidence(agreementId, evidenceType, evidenceHash, evidenceURI);
+    return tx.wait();
+  }
+
+  async nominateArbitrator(agreementId: bigint, arbitrator: string) {
+    const tx = await this.contract.nominateArbitrator(agreementId, arbitrator);
+    return tx.wait();
+  }
+
+  async castArbitrationVote(agreementId: bigint, vote: ArbitrationVote, providerAward: bigint, clientAward: bigint) {
+    const tx = await this.contract.castArbitrationVote(agreementId, vote, providerAward, clientAward);
+    return tx.wait();
+  }
+
+  async requestHumanEscalation(agreementId: bigint, reason: string) {
+    const tx = await this.contract.requestHumanEscalation(agreementId, reason);
+    return tx.wait();
+  }
+
+  async getAgreement(id: bigint): Promise<Agreement> {
+    const raw = await this.contract.getAgreement(id);
+    return {
+      id: BigInt(raw.id), client: raw.client, provider: raw.provider, serviceType: raw.serviceType,
+      description: raw.description, price: BigInt(raw.price), token: raw.token, deadline: BigInt(raw.deadline),
+      deliverablesHash: raw.deliverablesHash, status: Number(raw.status) as AgreementStatus,
+      createdAt: BigInt(raw.createdAt), resolvedAt: BigInt(raw.resolvedAt), verifyWindowEnd: BigInt(raw.verifyWindowEnd), committedHash: raw.committedHash,
+    };
+  }
+
+  async getRemediationCase(id: bigint): Promise<RemediationCase> {
+    const raw = await this.contract.getRemediationCase(id);
+    return { cycleCount: Number(raw.cycleCount), openedAt: BigInt(raw.openedAt), deadlineAt: BigInt(raw.deadlineAt), lastActionAt: BigInt(raw.lastActionAt), latestTranscriptHash: raw.latestTranscriptHash, active: raw.active };
+  }
+
+  async getRemediationFeedback(id: bigint, index: bigint): Promise<RemediationFeedback> {
+    const raw = await this.contract.getRemediationFeedback(id, index);
+    return { cycle: Number(raw.cycle), author: raw.author, feedbackHash: raw.feedbackHash, feedbackURI: raw.feedbackURI, previousTranscriptHash: raw.previousTranscriptHash, transcriptHash: raw.transcriptHash, timestamp: BigInt(raw.timestamp) };
+  }
+
+  async getRemediationResponse(id: bigint, index: bigint): Promise<RemediationResponse> {
+    const raw = await this.contract.getRemediationResponse(id, index);
+    return { cycle: Number(raw.cycle), author: raw.author, responseType: Number(raw.responseType) as ProviderResponseType, proposedProviderPayout: BigInt(raw.proposedProviderPayout), responseHash: raw.responseHash, responseURI: raw.responseURI, previousTranscriptHash: raw.previousTranscriptHash, transcriptHash: raw.transcriptHash, timestamp: BigInt(raw.timestamp) };
+  }
+
+  async getDisputeCase(id: bigint): Promise<DisputeCase> {
+    const raw = await this.contract.getDisputeCase(id);
+    return { agreementId: BigInt(raw.agreementId), openedAt: BigInt(raw.openedAt), responseDeadlineAt: BigInt(raw.responseDeadlineAt), outcome: Number(raw.outcome) as DisputeOutcome, providerAward: BigInt(raw.providerAward), clientAward: BigInt(raw.clientAward), humanReviewRequested: raw.humanReviewRequested, evidenceCount: BigInt(raw.evidenceCount) };
+  }
+
+  async getDisputeEvidence(id: bigint, index: bigint): Promise<DisputeEvidence> {
+    const raw = await this.contract.getDisputeEvidence(id, index);
+    return { submitter: raw.submitter, evidenceType: Number(raw.evidenceType) as EvidenceType, evidenceHash: raw.evidenceHash, evidenceURI: raw.evidenceURI, timestamp: BigInt(raw.timestamp) };
+  }
+
+  async getArbitrationCase(id: bigint): Promise<ArbitrationCase> {
+    const raw = await this.contract.getArbitrationCase(id);
+    return {
+      agreementId: BigInt(raw.agreementId),
+      arbitrators: [...raw.arbitrators],
+      arbitratorCount: Number(raw.arbitratorCount),
+      providerVotes: Number(raw.providerVotes),
+      clientVotes: Number(raw.clientVotes),
+      splitVotes: Number(raw.splitVotes),
+      humanVotes: Number(raw.humanVotes),
+      selectionDeadlineAt: BigInt(raw.selectionDeadlineAt),
+      decisionDeadlineAt: BigInt(raw.decisionDeadlineAt),
+      splitProviderAward: BigInt(raw.splitProviderAward),
+      splitClientAward: BigInt(raw.splitClientAward),
+      finalized: raw.finalized,
+      humanBackstopUsed: raw.humanBackstopUsed,
+    };
+  }
+
+  async getDisputeEvidenceAll(id: bigint): Promise<DisputeEvidence[]> {
+    const dispute = await this.getDisputeCase(id);
+    return Promise.all(Array.from({ length: Number(dispute.evidenceCount) }, (_, i) => this.getDisputeEvidence(id, BigInt(i))));
+  }
+
+  async getClientAgreements(client: string): Promise<Agreement[]> {
+    const ids = await this.contract.getAgreementsByClient(client) as bigint[];
+    return Promise.all(ids.map((id) => this.getAgreement(BigInt(id))));
+  }
+
+  async getProviderAgreements(provider: string): Promise<Agreement[]> {
+    const ids = await this.contract.getAgreementsByProvider(provider) as bigint[];
+    return Promise.all(ids.map((id) => this.getAgreement(BigInt(id))));
+  }
+}

package/src/capability.ts

@@ -0,0 +1,18 @@
+import { ContractRunner, ethers } from "ethers";
+import { CAPABILITY_REGISTRY_ABI } from "./contracts";
+import { CapabilityRoot } from "./types";
+
+export class CapabilityRegistryClient {
+  private contract: ethers.Contract;
+  constructor(address: string, runner: ContractRunner) { this.contract = new ethers.Contract(address, CAPABILITY_REGISTRY_ABI, runner); }
+  async registerRoot(root: string) { const tx = await this.contract.registerRoot(root); return tx.wait(); }
+  async setRootStatus(root: string, active: boolean) { const tx = await this.contract.setRootStatus(root, active); return tx.wait(); }
+  async claim(capability: string) { const tx = await this.contract.claim(capability); return tx.wait(); }
+  async revoke(capability: string) { const tx = await this.contract.revoke(capability); return tx.wait(); }
+  isRootActive(root: string) { return this.contract.isRootActive(root); }
+  async getRoot(root: string): Promise<CapabilityRoot> { const raw = await this.contract.getRoot(root); return { root: raw.root, rootId: raw.rootId, active: raw.active }; }
+  async listRoots(): Promise<CapabilityRoot[]> { const count = Number(await this.contract.rootCount()); return Promise.all(Array.from({ length: count }, async (_, i) => { const raw = await this.contract.getRootAt(i); return { root: raw.root, rootId: raw.rootId, active: raw.active }; })); }
+  getCapabilities(agent: string): Promise<string[]> { return this.contract.getCapabilities(agent); }
+  capabilityCount(agent: string) { return this.contract.capabilityCount(agent).then(BigInt); }
+  isCapabilityClaimed(agent: string, capability: string) { return this.contract.isCapabilityClaimed(agent, capability); }
+}