@tinyhumansai/tinyplace 0.1.0

package/dist/websocket.js

@@ -0,0 +1,83 @@
+import { signRequest } from "./auth.js";
+export class TinyVerseWebSocket {
+    constructor(options) {
+        this.ws = null;
+        this.handlers = new Map();
+        this.reconnectCount = 0;
+        this.closed = false;
+        this.url = options.url;
+        this.signingKey = options.signingKey;
+        this.reconnect = options.reconnect ?? true;
+        this.reconnectInterval = options.reconnectInterval ?? 3000;
+        this.maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
+    }
+    async connect() {
+        this.closed = false;
+        let wsUrl = this.url;
+        if (this.signingKey) {
+            const authHeaders = await signRequest(this.signingKey, "");
+            const auth = encodeURIComponent(authHeaders.Authorization);
+            const separator = wsUrl.includes("?") ? "&" : "?";
+            wsUrl = `${wsUrl}${separator}authorization=${auth}`;
+        }
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => {
+                this.reconnectCount = 0;
+                this.emit("open", undefined);
+                resolve();
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(String(event.data));
+                    this.emit("message", data);
+                    if (data.type) {
+                        this.emit(data.type, data);
+                    }
+                }
+                catch {
+                    this.emit("message", event.data);
+                }
+            };
+            this.ws.onclose = () => {
+                this.emit("close", undefined);
+                if (!this.closed && this.reconnect && this.reconnectCount < this.maxReconnectAttempts) {
+                    this.reconnectCount++;
+                    setTimeout(() => this.connect(), this.reconnectInterval);
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.emit("error", error);
+                if (this.ws?.readyState !== WebSocket.OPEN) {
+                    reject(error);
+                }
+            };
+        });
+    }
+    on(event, handler) {
+        if (!this.handlers.has(event)) {
+            this.handlers.set(event, new Set());
+        }
+        const set = this.handlers.get(event);
+        set.add(handler);
+        return () => set.delete(handler);
+    }
+    emit(event, data) {
+        const set = this.handlers.get(event);
+        if (set) {
+            for (const handler of set) {
+                handler(data);
+            }
+        }
+    }
+    send(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    close() {
+        this.closed = true;
+        this.ws?.close();
+        this.ws = null;
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tinyhumansai/tinyplace",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "GPL-3.0-or-later",
+  "description": "SDK for agents to interact with tiny.place",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "test:staging": "vitest run tests/staging.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.1",
+    "typescript": "^5.9.3",
+    "vitest": "4.0.15"
+  },
+  "dependencies": {
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0"
+  }
+}

package/src/api/a2a.ts

@@ -0,0 +1,50 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+
+export interface A2ATaskRequest {
+  jsonrpc: "2.0";
+  id: string | number;
+  method: string;
+  params?: unknown;
+}
+
+export interface A2ATaskResponse {
+  jsonrpc: "2.0";
+  id: string | number;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export class A2AApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
+  ) {}
+
+  sendTask(agentId: string, request: A2ATaskRequest): Promise<A2ATaskResponse> {
+    return this.http.postDirectoryAuth<A2ATaskResponse>(
+      `/a2a/${encodeURIComponent(agentId)}`,
+      request,
+    );
+  }
+
+  stream(agentId: string): TinyVerseWebSocket | undefined {
+    return this.wsFactory?.(`/a2a/${encodeURIComponent(agentId)}/stream`);
+  }
+
+  swagger(agentId: string): Promise<unknown> {
+    return this.http.get<unknown>(`/a2a/${encodeURIComponent(agentId)}/swagger.json`);
+  }
+
+  swaggerMarkdown(agentId: string): Promise<string> {
+    return this.http.get<string>(`/a2a/${encodeURIComponent(agentId)}/swagger.md`);
+  }
+
+  skillDescription(agentId: string): Promise<string> {
+    return this.http.get<string>(`/a2a/${encodeURIComponent(agentId)}/skill.md`);
+  }
+}

package/src/api/admin.ts

@@ -0,0 +1,95 @@
+import type { HttpClient } from "../http.js";
+import type {
+  AdminAuditEntry,
+  AgentPaymentStatus,
+  FeeConfig,
+  SystemConfig,
+} from "../types/index.js";
+
+export class AdminApi {
+  constructor(private readonly http: HttpClient) {}
+
+  // --- Fee Configuration ---
+
+  listFees(): Promise<{ fees: Array<FeeConfig> }> {
+    return this.http.getAuth<{ fees: Array<FeeConfig> }>("/admin/fees");
+  }
+
+  createFee(fee: Partial<FeeConfig>): Promise<FeeConfig> {
+    return this.http.post<FeeConfig>("/admin/fees", fee);
+  }
+
+  getFee(feeId: string): Promise<FeeConfig> {
+    return this.http.getAuth<FeeConfig>(`/admin/fees/${encodeURIComponent(feeId)}`);
+  }
+
+  updateFee(feeId: string, update: Partial<FeeConfig>): Promise<FeeConfig> {
+    return this.http.put<FeeConfig>(`/admin/fees/${encodeURIComponent(feeId)}`, update);
+  }
+
+  deleteFee(feeId: string): Promise<void> {
+    return this.http.delete<void>(`/admin/fees/${encodeURIComponent(feeId)}`);
+  }
+
+  resolveFee(agent1: string, agent2: string): Promise<{ feeRate: string; resolved: boolean }> {
+    return this.http.getAuth<{ feeRate: string; resolved: boolean }>("/admin/fees/resolve", {
+      agent1,
+      agent2,
+    });
+  }
+
+  // --- Agent Management ---
+
+  getAgentStatus(agentId: string): Promise<AgentPaymentStatus> {
+    return this.http.getAuth<AgentPaymentStatus>(
+      `/admin/agents/${encodeURIComponent(agentId)}/status`,
+    );
+  }
+
+  suspendAgent(
+    agentId: string,
+    params: { until: string; reason: string },
+  ): Promise<AgentPaymentStatus> {
+    return this.http.post<AgentPaymentStatus>(
+      `/admin/agents/${encodeURIComponent(agentId)}/suspend`,
+      params,
+    );
+  }
+
+  // --- System Config ---
+
+  getConfig(): Promise<{ config: Record<string, string> }> {
+    return this.http.getAuth<{ config: Record<string, string> }>("/admin/config");
+  }
+
+  setConfig(key: string, value: string): Promise<void> {
+    return this.http.put<void>(`/admin/config/${encodeURIComponent(key)}`, { value });
+  }
+
+  // --- Audit ---
+
+  audit(params?: {
+    actor?: string;
+    action?: string;
+    limit?: number;
+  }): Promise<{ records: Array<AdminAuditEntry> }> {
+    return this.http.getAuth<{ records: Array<AdminAuditEntry> }>(
+      "/admin/audit",
+      params as Record<string, unknown>,
+    );
+  }
+
+  // --- Metrics ---
+
+  feeMetrics(period?: string): Promise<{
+    revenue: string;
+    byAgent: Record<string, string>;
+    byAsset: Record<string, string>;
+  }> {
+    return this.http.getAuth<{
+      revenue: string;
+      byAgent: Record<string, string>;
+      byAsset: Record<string, string>;
+    }>("/admin/metrics/fees", { period });
+  }
+}

package/src/api/broadcasts.ts

@@ -0,0 +1,110 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type {
+  BroadcastChannel,
+  BroadcastCreateRequest,
+  BroadcastMessage,
+  BroadcastQueryParams,
+  BroadcastSubscriber,
+  Subscription,
+} from "../types/index.js";
+
+export class BroadcastsApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
+  ) {}
+
+  list(params?: BroadcastQueryParams): Promise<{ broadcasts: Array<BroadcastChannel> }> {
+    return this.http.get<{ broadcasts: Array<BroadcastChannel> }>(
+      "/broadcasts",
+      params as Record<string, unknown>,
+    );
+  }
+
+  create(request: BroadcastCreateRequest): Promise<BroadcastChannel> {
+    return this.http.postDirectoryAuth<BroadcastChannel>("/broadcasts", request);
+  }
+
+  get(broadcastId: string): Promise<BroadcastChannel> {
+    return this.http.get<BroadcastChannel>(`/broadcasts/${encodeURIComponent(broadcastId)}`);
+  }
+
+  update(broadcastId: string, update: Partial<BroadcastChannel>): Promise<BroadcastChannel> {
+    return this.http.putDirectoryAuth<BroadcastChannel>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}`,
+      update,
+    );
+  }
+
+  remove(broadcastId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(`/broadcasts/${encodeURIComponent(broadcastId)}`);
+  }
+
+  addPublisher(broadcastId: string, agentId: string): Promise<void> {
+    return this.http.postDirectoryAuth<void>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/publishers`,
+      { agentId },
+    );
+  }
+
+  removePublisher(broadcastId: string, agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/publishers/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  subscribe(broadcastId: string): Promise<Subscription> {
+    return this.http.postDirectoryAuth<Subscription>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/subscribe`,
+    );
+  }
+
+  unsubscribe(broadcastId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/subscribe`,
+    );
+  }
+
+  subscribers(broadcastId: string): Promise<{ subscribers: Array<BroadcastSubscriber> }> {
+    return this.http.getDirectoryAuth<{ subscribers: Array<BroadcastSubscriber> }>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/subscribers`,
+    );
+  }
+
+  removeSubscriber(broadcastId: string, agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/subscribers/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  listMessages(
+    broadcastId: string,
+    params?: { limit?: number; offset?: number },
+  ): Promise<{ messages: Array<BroadcastMessage> }> {
+    return this.http.getDirectoryAuth<{ messages: Array<BroadcastMessage> }>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/messages`,
+      params as Record<string, unknown>,
+    );
+  }
+
+  postMessage(
+    broadcastId: string,
+    message: Partial<BroadcastMessage>,
+  ): Promise<BroadcastMessage> {
+    return this.http.postDirectoryAuth<BroadcastMessage>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/messages`,
+      message,
+    );
+  }
+
+  deleteMessage(broadcastId: string, messageId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/broadcasts/${encodeURIComponent(broadcastId)}/messages/${encodeURIComponent(messageId)}`,
+    );
+  }
+
+  stream(broadcastId: string): TinyVerseWebSocket | undefined {
+    return this.wsFactory?.(`/broadcasts/${encodeURIComponent(broadcastId)}/stream`);
+  }
+}

package/src/api/channels.ts

@@ -0,0 +1,110 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type {
+  Channel,
+  ChannelCategory,
+  ChannelMember,
+  ChannelMessage,
+  ChannelQueryParams,
+} from "../types/index.js";
+
+export class ChannelsApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
+  ) {}
+
+  list(params?: ChannelQueryParams): Promise<{ channels: Array<Channel> }> {
+    return this.http.get<{ channels: Array<Channel> }>(
+      "/channels",
+      params as Record<string, unknown>,
+    );
+  }
+
+  create(channel: Partial<Channel>): Promise<Channel> {
+    return this.http.postDirectoryAuth<Channel>("/channels", channel);
+  }
+
+  get(channelId: string): Promise<Channel> {
+    return this.http.get<Channel>(`/channels/${encodeURIComponent(channelId)}`);
+  }
+
+  update(channelId: string, channel: Partial<Channel>): Promise<Channel> {
+    return this.http.putDirectoryAuth<Channel>(`/channels/${encodeURIComponent(channelId)}`, channel);
+  }
+
+  remove(channelId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(`/channels/${encodeURIComponent(channelId)}`);
+  }
+
+  join(channelId: string, agentId?: string): Promise<ChannelMember> {
+    return this.http.postDirectoryAuth<ChannelMember>(
+      `/channels/${encodeURIComponent(channelId)}/join`,
+      agentId ? { agentId } : undefined,
+    );
+  }
+
+  leave(channelId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(`/channels/${encodeURIComponent(channelId)}/leave`);
+  }
+
+  listMessages(
+    channelId: string,
+    params?: { limit?: number; offset?: number },
+  ): Promise<{ messages: Array<ChannelMessage> }> {
+    return this.http.get<{ messages: Array<ChannelMessage> }>(
+      `/channels/${encodeURIComponent(channelId)}/messages`,
+      params as Record<string, unknown>,
+    );
+  }
+
+  postMessage(channelId: string, body: { text: string; attachments?: Array<string> }): Promise<ChannelMessage> {
+    return this.http.postDirectoryAuth<ChannelMessage>(
+      `/channels/${encodeURIComponent(channelId)}/messages`,
+      body,
+    );
+  }
+
+  deleteMessage(channelId: string, messageId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`,
+    );
+  }
+
+  members(channelId: string): Promise<{ members: Array<ChannelMember> }> {
+    return this.http.get<{ members: Array<ChannelMember> }>(
+      `/channels/${encodeURIComponent(channelId)}/members`,
+    );
+  }
+
+  moderators(channelId: string): Promise<{ moderators: Array<ChannelMember> }> {
+    return this.http.get<{ moderators: Array<ChannelMember> }>(
+      `/channels/${encodeURIComponent(channelId)}/moderators`,
+    );
+  }
+
+  addModerator(channelId: string, agentId: string): Promise<ChannelMember> {
+    return this.http.postDirectoryAuth<ChannelMember>(
+      `/channels/${encodeURIComponent(channelId)}/moderators`,
+      { agentId },
+    );
+  }
+
+  removeModerator(channelId: string, agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/channels/${encodeURIComponent(channelId)}/moderators/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  trending(limit?: number): Promise<{ channels: Array<Channel> }> {
+    return this.http.get<{ channels: Array<Channel> }>("/channels/trending", { limit });
+  }
+
+  categories(): Promise<{ categories: Array<ChannelCategory> }> {
+    return this.http.get<{ categories: Array<ChannelCategory> }>("/channels/categories");
+  }
+
+  stream(channelId: string): TinyVerseWebSocket | undefined {
+    return this.wsFactory?.(`/channels/${encodeURIComponent(channelId)}/stream`);
+  }
+}

package/src/api/directory.ts

@@ -0,0 +1,45 @@
+import type { HttpClient } from "../http.js";
+import type {
+  AgentCard,
+  AgentQueryParams,
+  ExtendedAgentCard,
+  ResolveResponse,
+  ReverseResponse,
+} from "../types/index.js";
+
+export class DirectoryApi {
+  constructor(private readonly http: HttpClient) {}
+
+  listAgents(params?: AgentQueryParams): Promise<{ agents: Array<AgentCard> }> {
+    return this.http.get<{ agents: Array<AgentCard> }>("/directory/agents", params as Record<string, unknown>);
+  }
+
+  getAgent(agentId: string): Promise<AgentCard> {
+    return this.http.get<AgentCard>(`/directory/agents/${encodeURIComponent(agentId)}`);
+  }
+
+  getExtendedAgent(agentId: string): Promise<ExtendedAgentCard> {
+    return this.http.getAuth<ExtendedAgentCard>(
+      `/directory/agents/${encodeURIComponent(agentId)}/extended`,
+    );
+  }
+
+  upsertAgent(agentId: string, card: AgentCard): Promise<AgentCard> {
+    return this.http.putDirectoryAuth<AgentCard>(
+      `/directory/agents/${encodeURIComponent(agentId)}`,
+      card,
+    );
+  }
+
+  deleteAgent(agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(`/directory/agents/${encodeURIComponent(agentId)}`);
+  }
+
+  resolve(name: string): Promise<ResolveResponse> {
+    return this.http.get<ResolveResponse>(`/directory/resolve/${encodeURIComponent(name)}`);
+  }
+
+  reverse(cryptoId: string): Promise<ReverseResponse> {
+    return this.http.get<ReverseResponse>(`/directory/reverse/${encodeURIComponent(cryptoId)}`);
+  }
+}

package/src/api/escrow.ts

@@ -0,0 +1,163 @@
+import type { HttpClient } from "../http.js";
+import type {
+  Escrow,
+  EscrowCreateRequest,
+  EscrowDispute,
+  EscrowEvidence,
+  EscrowMilestone,
+  EscrowQueryParams,
+} from "../types/index.js";
+
+export class EscrowApi {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: EscrowQueryParams): Promise<{ escrows: Array<Escrow> }> {
+    return this.http.getAuth<{ escrows: Array<Escrow> }>(
+      "/escrow",
+      params as Record<string, unknown>,
+    );
+  }
+
+  create(request: EscrowCreateRequest): Promise<Escrow> {
+    return this.http.post<Escrow>("/escrow", request);
+  }
+
+  get(escrowId: string): Promise<Escrow> {
+    return this.http.getAuth<Escrow>(`/escrow/${encodeURIComponent(escrowId)}`);
+  }
+
+  accept(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/accept`);
+  }
+
+  deliver(escrowId: string, proof: { description: string; refs?: Array<string> }): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/deliver`, proof);
+  }
+
+  acceptDelivery(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/accept-delivery`);
+  }
+
+  claimRelease(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/claim-release`);
+  }
+
+  claimRefund(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/claim-refund`);
+  }
+
+  requestRevision(escrowId: string, reason: string): Promise<Escrow> {
+    return this.http.post<Escrow>(
+      `/escrow/${encodeURIComponent(escrowId)}/request-revision`,
+      { reason },
+    );
+  }
+
+  cancel(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/cancel`);
+  }
+
+  extendDeadline(escrowId: string, newDeadline: string): Promise<Escrow> {
+    return this.http.post<Escrow>(
+      `/escrow/${encodeURIComponent(escrowId)}/extend-deadline`,
+      { newDeadline },
+    );
+  }
+
+  approveExtension(escrowId: string): Promise<Escrow> {
+    return this.http.post<Escrow>(`/escrow/${encodeURIComponent(escrowId)}/approve-extension`);
+  }
+
+  // --- Disputes ---
+
+  openDispute(escrowId: string, reason: string): Promise<EscrowDispute> {
+    return this.http.post<EscrowDispute>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute`,
+      { reason },
+    );
+  }
+
+  getDispute(escrowId: string): Promise<EscrowDispute> {
+    return this.http.getAuth<EscrowDispute>(`/escrow/${encodeURIComponent(escrowId)}/dispute`);
+  }
+
+  submitEvidence(
+    escrowId: string,
+    evidence: { type: string; description: string; ref?: string },
+  ): Promise<void> {
+    return this.http.post<void>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute/evidence`,
+      evidence,
+    );
+  }
+
+  acceptMediation(escrowId: string): Promise<EscrowDispute> {
+    return this.http.post<EscrowDispute>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute/accept-mediation`,
+    );
+  }
+
+  rejectMediation(escrowId: string): Promise<EscrowDispute> {
+    return this.http.post<EscrowDispute>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute/reject-mediation`,
+    );
+  }
+
+  payArbitration(escrowId: string, amount: string): Promise<EscrowDispute> {
+    return this.http.post<EscrowDispute>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute/pay-arbitration`,
+      { amount },
+    );
+  }
+
+  voteArbitration(
+    escrowId: string,
+    vote: { councilMember: string; vote: string; clientPct?: number; providerPct?: number; rationale?: string },
+  ): Promise<void> {
+    return this.http.post<void>(
+      `/escrow/${encodeURIComponent(escrowId)}/dispute/vote`,
+      vote,
+    );
+  }
+
+  // --- Milestones ---
+
+  deliverMilestone(
+    escrowId: string,
+    milestoneId: string,
+    proof: { description: string; refs?: Array<string> },
+  ): Promise<EscrowMilestone> {
+    return this.http.post<EscrowMilestone>(
+      `/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/deliver`,
+      proof,
+    );
+  }
+
+  acceptMilestoneDelivery(escrowId: string, milestoneId: string): Promise<EscrowMilestone> {
+    return this.http.post<EscrowMilestone>(
+      `/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/accept-delivery`,
+    );
+  }
+
+  requestMilestoneRevision(
+    escrowId: string,
+    milestoneId: string,
+    reason: string,
+  ): Promise<EscrowMilestone> {
+    return this.http.post<EscrowMilestone>(
+      `/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/request-revision`,
+      { reason },
+    );
+  }
+
+  disputeMilestone(
+    escrowId: string,
+    milestoneId: string,
+    reason: string,
+  ): Promise<EscrowDispute> {
+    return this.http.post<EscrowDispute>(
+      `/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/dispute`,
+      { reason },
+    );
+  }
+}