@arc402/sdk 0.2.0

package/src/governance.ts

@@ -0,0 +1,14 @@
+import { ContractRunner, ethers } from "ethers";
+import { GOVERNANCE_ABI } from "./contracts";
+import { GovernanceTransaction } from "./types";
+
+export class GovernanceClient {
+  private contract: ethers.Contract;
+  constructor(address: string, runner: ContractRunner) { this.contract = new ethers.Contract(address, GOVERNANCE_ABI, runner); }
+  async submitTransaction(target: string, value: bigint, data: string) { const tx = await this.contract.submitTransaction(target, value, data); return tx.wait(); }
+  async confirmTransaction(txId: bigint) { const tx = await this.contract.confirmTransaction(txId); return tx.wait(); }
+  async revokeConfirmation(txId: bigint) { const tx = await this.contract.revokeConfirmation(txId); return tx.wait(); }
+  async executeTransaction(txId: bigint) { const tx = await this.contract.executeTransaction(txId); return tx.wait(); }
+  async getTransaction(txId: bigint): Promise<GovernanceTransaction> { const raw = await this.contract.getTransaction(txId); return { target: raw.target, value: BigInt(raw.value), data: raw.data, executed: raw.executed, confirmationCount: BigInt(raw.confirmationCount) }; }
+  transactionCount() { return this.contract.transactionCount().then(BigInt); }
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+export { ARC402WalletClient, ARC402Wallet, type ContextBinding } from "./wallet";
+export { ARC402WalletClient as ARC402OperatorClient, ARC402Wallet as ARC402Operator } from "./wallet";
+export { ContractInteractionClient, type IntentPayload, type ContractCallAttestation, type ContractCallResult } from "./contractinteraction";
+export { PolicyClient, PolicyObject, PolicyValidator } from "./policy";
+export { TrustClient, TrustPrimitive } from "./trust";
+export { IntentAttestationClient, IntentAttestation } from "./intent";
+export { SettlementClient, MultiAgentSettlement } from "./settlement";
+export { AgentRegistryClient, type AgentRegistrationInput } from "./agent";
+export { ServiceAgreementClient } from "./agreement";
+export { DisputeArbitrationClient } from "./dispute-arbitration";
+export { ReputationOracleClient } from "./reputation";
+export { SponsorshipAttestationClient } from "./sponsorship";
+export { CapabilityRegistryClient } from "./capability";
+export { GovernanceClient } from "./governance";
+export { signNegotiationMessage, createSignedProposal, createSignedCounter, createSignedAccept, createSignedReject, createNegotiationProposal, createNegotiationCounter, createNegotiationAccept, createNegotiationReject, parseNegotiationMessage } from "./negotiation";
+export { NegotiationGuard } from "./negotiation-guard";
+export { SessionManager } from "./session-manager";
+export { ChannelClient } from "./channel";
+export { AgreementTreeClient, type AgreementTree, type PaymentSplit, type PaymentDistribution, type CreateAgreementResult } from "./multiparty";
+export { WatchtowerClient } from "./watchtower";
+export type { WatchtowerMetadata, WatchtowerStatus } from "./watchtower";
+export { DeliverableClient, DeliverableType, hashDeliverable, hashDeliverableFile, uploadToIPFS, encryptDeliverable, decryptDeliverable, uploadEncryptedIPFS } from "./deliverable";
+export type { DeliverableManifest, DeliverableManifestEntry, IPFSUploadOptions, IPFSUploadResult, EncryptedDeliverable } from "./deliverable";
+export type { NegotiationVerificationResult, NegotiationVerificationError, SignedNegotiationMessage } from "./types";
+export type { ChannelState, Channel, ChannelStatus, OpenChannelParams } from "./types";
+export * from "./contracts";
+export * from "./types";
+export { buildMetadata, validateMetadata, encodeMetadata, decodeMetadata, uploadMetadata, AGENT_METADATA_SCHEMA } from "./metadata";
+export type { AgentMetadata, AgentMetadataModel, AgentMetadataTraining, AgentMetadataPricing, AgentMetadataSla, AgentMetadataContact, AgentMetadataSecurity } from "./metadata";
+export { ColdStartClient } from "./coldstart";
+export { MigrationClient } from "./migration";

package/src/intent.ts

@@ -0,0 +1,22 @@
+import { ContractRunner, ethers } from "ethers";
+import { INTENT_ATTESTATION_ABI } from "./contracts";
+import { Intent } from "./types";
+
+export class IntentAttestationClient {
+  private contract: ethers.Contract;
+  constructor(address: string, runner: ContractRunner, private walletAddress: string) {
+    this.contract = new ethers.Contract(address, INTENT_ATTESTATION_ABI, runner);
+  }
+  async create(action: string, reason: string, recipient: string, amount: bigint): Promise<string> {
+    const attestationId = ethers.keccak256(ethers.toUtf8Bytes(`${this.walletAddress}:${action}:${reason}:${recipient}:${amount}:${Date.now()}`));
+    const tx = await this.contract.attest(attestationId, action, reason, recipient, amount);
+    await tx.wait();
+    return attestationId;
+  }
+  verify(attestationId: string, walletAddress: string) { return this.contract.verify(attestationId, walletAddress); }
+  async get(attestationId: string): Promise<Intent> {
+    const [id, wallet, action, reason, recipient, amount, timestamp] = await this.contract.getAttestation(attestationId);
+    return { attestationId: id, wallet, action, reason, recipient, amount: BigInt(amount), timestamp: Number(timestamp) };
+  }
+}
+export class IntentAttestation extends IntentAttestationClient {}

package/src/metadata.ts

@@ -0,0 +1,158 @@
+// ARC-402 Spec 23: Agent Metadata Standard
+
+export const AGENT_METADATA_SCHEMA = "arc402.agent-metadata.v1";
+
+export interface AgentMetadataModel {
+  family?: string;
+  version?: string;
+  provider?: string;
+  contextWindow?: number;
+  multimodal?: boolean;
+}
+
+export interface AgentMetadataTraining {
+  disclosure?: string;
+  dataCutoff?: string;
+  specialisations?: string[];
+  synopsis?: string;
+  verified?: boolean;
+  attestations?: unknown[];
+}
+
+export interface AgentMetadataPricing {
+  base?: string;
+  token?: string;
+  currency?: string;
+  per?: string;
+}
+
+export interface AgentMetadataSla {
+  turnaroundHours?: number;
+  availability?: string;
+  maxConcurrentJobs?: number;
+}
+
+export interface AgentMetadataContact {
+  endpoint?: string;
+  relay?: string;
+  relayFallbacks?: string[];
+}
+
+export interface AgentMetadataSecurity {
+  injectionProtection?: boolean;
+  envLeakProtection?: boolean;
+  attestedSecurityPolicy?: boolean;
+}
+
+export interface AgentMetadata {
+  schema: string;
+  name?: string;
+  description?: string;
+  capabilities?: string[];
+  model?: AgentMetadataModel;
+  training?: AgentMetadataTraining;
+  pricing?: AgentMetadataPricing;
+  sla?: AgentMetadataSla;
+  contact?: AgentMetadataContact;
+  security?: AgentMetadataSecurity;
+}
+
+export function validateMetadata(obj: unknown): AgentMetadata {
+  if (typeof obj !== "object" || obj === null) {
+    throw new Error("metadata must be an object");
+  }
+  const m = obj as Record<string, unknown>;
+  if (typeof m["schema"] !== "string") {
+    throw new Error("metadata.schema must be a string");
+  }
+  if (m["schema"] !== AGENT_METADATA_SCHEMA) {
+    throw new Error(`metadata.schema must be "${AGENT_METADATA_SCHEMA}", got "${m["schema"]}"`);
+  }
+  if (m["name"] !== undefined && typeof m["name"] !== "string") {
+    throw new Error("metadata.name must be a string");
+  }
+  if (m["description"] !== undefined && typeof m["description"] !== "string") {
+    throw new Error("metadata.description must be a string");
+  }
+  if (m["capabilities"] !== undefined) {
+    if (!Array.isArray(m["capabilities"]) || !m["capabilities"].every((c: unknown) => typeof c === "string")) {
+      throw new Error("metadata.capabilities must be a string array");
+    }
+  }
+  return m as unknown as AgentMetadata;
+}
+
+export function buildMetadata(input: Partial<AgentMetadata>): AgentMetadata {
+  const meta: AgentMetadata = {
+    schema: AGENT_METADATA_SCHEMA,
+    ...input,
+  };
+  if (meta.training) {
+    meta.training = {
+      verified: false,
+      attestations: [],
+      ...meta.training,
+    };
+  }
+  if (meta.security) {
+    meta.security = {
+      attestedSecurityPolicy: false,
+      ...meta.security,
+    };
+  }
+  return meta;
+}
+
+export function encodeMetadata(metadata: AgentMetadata): string {
+  return JSON.stringify(metadata, null, 2);
+}
+
+function resolveIpfsUri(uri: string): string {
+  if (uri.startsWith("ipfs://")) {
+    return `https://ipfs.io/ipfs/${uri.slice(7)}`;
+  }
+  return uri;
+}
+
+export async function decodeMetadata(uri: string): Promise<AgentMetadata> {
+  if (uri.startsWith("data:")) {
+    // data:application/json;base64,<b64> or data:application/json,<encoded>
+    const commaIdx = uri.indexOf(",");
+    if (commaIdx === -1) throw new Error("malformed data URI");
+    const header = uri.slice(5, commaIdx);
+    const payload = uri.slice(commaIdx + 1);
+    const isBase64 = header.includes(";base64");
+    const json = isBase64 ? Buffer.from(payload, "base64").toString("utf-8") : decodeURIComponent(payload);
+    return validateMetadata(JSON.parse(json));
+  }
+  const url = resolveIpfsUri(uri);
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`failed to fetch metadata from ${url}: ${res.status} ${res.statusText}`);
+  const json = await res.json();
+  return validateMetadata(json);
+}
+
+export async function uploadMetadata(metadata: AgentMetadata, pinataJwt?: string): Promise<string> {
+  if (pinataJwt) {
+    const res = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${pinataJwt}`,
+      },
+      body: JSON.stringify({
+        pinataContent: metadata,
+        pinataMetadata: { name: `arc402-agent-metadata-${metadata.name ?? "unknown"}` },
+      }),
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Pinata upload failed: ${res.status} ${text}`);
+    }
+    const data = await res.json() as { IpfsHash: string };
+    return `ipfs://${data.IpfsHash}`;
+  }
+  // Fallback: data URI (no IPFS credentials configured)
+  const b64 = Buffer.from(encodeMetadata(metadata), "utf-8").toString("base64");
+  return `data:application/json;base64,${b64}`;
+}

package/src/migration.ts

@@ -0,0 +1,43 @@
+import { ContractRunner, ethers } from "ethers";
+
+const MIGRATION_REGISTRY_ABI = [
+  "function registerMigration(address oldWallet, address newWallet) external",
+  "function resolveActiveWallet(address wallet) external view returns (address)",
+  "function getLineage(address wallet) external view returns (address[])",
+  "function approveMigrationTarget(address implementation) external",
+  "function migratedTo(address wallet) external view returns (address)",
+  "function migratedFrom(address wallet) external view returns (address)",
+] as const;
+
+export class MigrationClient {
+  private address: string;
+  private runner?: ContractRunner;
+
+  constructor(address: string, runner?: ContractRunner) {
+    this.address = address;
+    this.runner = runner;
+  }
+
+  async registerMigration(oldWallet: string, newWallet: string, signer: ContractRunner): Promise<ethers.TransactionReceipt> {
+    const contract = new ethers.Contract(this.address, MIGRATION_REGISTRY_ABI, signer);
+    const tx = await contract.registerMigration(oldWallet, newWallet);
+    return tx.wait();
+  }
+
+  async resolveActiveWallet(wallet: string): Promise<string> {
+    const contract = new ethers.Contract(this.address, MIGRATION_REGISTRY_ABI, this.runner);
+    return contract.resolveActiveWallet(wallet);
+  }
+
+  async getLineage(wallet: string): Promise<string[]> {
+    const contract = new ethers.Contract(this.address, MIGRATION_REGISTRY_ABI, this.runner);
+    const result = await contract.getLineage(wallet);
+    return [...result];
+  }
+
+  async approveMigrationTarget(impl: string, signer: ContractRunner): Promise<ethers.TransactionReceipt> {
+    const contract = new ethers.Contract(this.address, MIGRATION_REGISTRY_ABI, signer);
+    const tx = await contract.approveMigrationTarget(impl);
+    return tx.wait();
+  }
+}

package/src/multiparty.ts

@@ -0,0 +1,132 @@
+import { ContractRunner, ethers } from "ethers";
+import { AGREEMENT_TREE_ABI } from "./contracts";
+import { ServiceAgreementClient } from "./agreement";
+import { ProposeParams } from "./types";
+
+export interface AgreementTree {
+  root: bigint;
+  path: bigint[];
+  children: bigint[];
+  depth: number;
+  allSettled: boolean;
+}
+
+export interface PaymentSplit {
+  address: string;
+  percentage: number;
+}
+
+export interface PaymentDistribution {
+  total: bigint;
+  distributions: Array<{ address: string; amount: bigint; percentage: number }>;
+}
+
+export interface CreateAgreementResult {
+  rootAgreementId: bigint;
+  childAgreementIds: bigint[];
+}
+
+export class AgreementTreeClient {
+  private treeContract: ethers.Contract;
+  private agreementClient: ServiceAgreementClient;
+
+  constructor(treeAddress: string, agreementAddress: string, runner: ContractRunner) {
+    this.treeContract = new ethers.Contract(treeAddress, AGREEMENT_TREE_ABI, runner);
+    this.agreementClient = new ServiceAgreementClient(agreementAddress, runner);
+  }
+
+  async registerSubAgreement(params: {
+    parentAgreementId: bigint;
+    childAgreementId: bigint;
+  }): Promise<ethers.TransactionReceipt> {
+    const tx = await this.treeContract.registerSubAgreement(
+      params.parentAgreementId,
+      params.childAgreementId,
+    );
+    return tx.wait();
+  }
+
+  /**
+   * Propose the root agreement, then propose each child agreement and register
+   * them all under the root in the AgreementTree contract.
+   *
+   * The caller must be the client for the root agreement AND the provider for
+   * all child agreements (i.e. the middle-layer agent that subcontracts work).
+   */
+  async createAgreement(
+    rootTerms: ProposeParams,
+    childAgreements: ProposeParams[],
+  ): Promise<CreateAgreementResult> {
+    const { agreementId: rootAgreementId } = await this.agreementClient.propose(rootTerms);
+
+    const childAgreementIds: bigint[] = [];
+    for (const child of childAgreements) {
+      const { agreementId: childId } = await this.agreementClient.propose(child);
+      await this.registerSubAgreement({
+        parentAgreementId: rootAgreementId,
+        childAgreementId: childId,
+      });
+      childAgreementIds.push(childId);
+    }
+
+    return { rootAgreementId, childAgreementIds };
+  }
+
+  async getAgreementTree(rootAgreementId: bigint): Promise<AgreementTree> {
+    const id = BigInt(rootAgreementId);
+    const [root, path, children, depth, allSettled] = await Promise.all([
+      this.treeContract.getRoot(id),
+      this.treeContract.getPath(id),
+      this.treeContract.getChildren(id),
+      this.treeContract.getDepth(id),
+      this.treeContract.allChildrenSettled(id),
+    ]);
+    return {
+      root: BigInt(root),
+      path: (path as bigint[]).map(BigInt),
+      children: (children as bigint[]).map(BigInt),
+      depth: Number(depth),
+      allSettled: Boolean(allSettled),
+    };
+  }
+
+  /** Alias for getAgreementTree — matches spec SDK interface. */
+  async getTree(agreementId: bigint): Promise<AgreementTree> {
+    return this.getAgreementTree(agreementId);
+  }
+
+  async treeStatus(agreementId: bigint): Promise<{ allSettled: boolean; childCount: number }> {
+    const [allSettled, children] = await Promise.all([
+      this.treeContract.allChildrenSettled(BigInt(agreementId)),
+      this.treeContract.getChildren(BigInt(agreementId)),
+    ]);
+    return {
+      allSettled: Boolean(allSettled),
+      childCount: (children as bigint[]).length,
+    };
+  }
+
+  /**
+   * Off-chain payment distribution helper.
+   * Splits paymentAmount across recipients according to their percentage shares.
+   * Percentages must sum to 100. This does not touch the chain.
+   */
+  splitPayment(
+    paymentAmount: bigint,
+    splits: PaymentSplit[],
+  ): PaymentDistribution {
+    const totalPct = splits.reduce((sum, s) => sum + s.percentage, 0);
+    if (Math.abs(totalPct - 100) > 0.001) {
+      throw new Error(`Split percentages must sum to 100 (got ${totalPct})`);
+    }
+
+    const distributions = splits.map((s) => ({
+      address: s.address,
+      percentage: s.percentage,
+      // Use integer basis points (x100) to avoid floating-point in BigInt arithmetic
+      amount: (paymentAmount * BigInt(Math.round(s.percentage * 100))) / 10000n,
+    }));
+
+    return { total: paymentAmount, distributions };
+  }
+}

package/src/negotiation-guard.ts

@@ -0,0 +1,125 @@
+import { ethers } from "ethers";
+import type { ContractRunner } from "ethers";
+import type { NegotiationMessage, NegotiationVerificationResult } from "./types";
+import { computeMessageDigest } from "./negotiation";
+
+const AGENT_REGISTRY_ABI = [
+  "function isRegistered(address wallet) view returns (bool)",
+];
+
+export interface NegotiationGuardOptions {
+  agentRegistryAddress: string;
+  runner: ContractRunner;
+  timestampToleranceSeconds?: number; // default 60
+  nonceCacheTtlMs?: number;           // default 24h
+  maxMessageBytes?: number;           // default 64KB
+}
+
+export class NegotiationGuard {
+  private registry: ethers.Contract;
+  private nonceCache = new Map<string, number>(); // nonceKey -> expiry timestamp (ms)
+  private opts: Required<NegotiationGuardOptions>;
+
+  constructor(options: NegotiationGuardOptions) {
+    this.opts = {
+      timestampToleranceSeconds: 60,
+      nonceCacheTtlMs: 24 * 60 * 60 * 1000,
+      maxMessageBytes: 64 * 1024,
+      ...options,
+    };
+    this.registry = new ethers.Contract(
+      options.agentRegistryAddress,
+      AGENT_REGISTRY_ABI,
+      options.runner
+    );
+  }
+
+  async verify(rawJson: string): Promise<NegotiationVerificationResult> {
+    // 1. Size check
+    if (Buffer.byteLength(rawJson, "utf8") > this.opts.maxMessageBytes) {
+      return { valid: false, error: "MESSAGE_TOO_LARGE" };
+    }
+
+    // 2. Parse
+    let message: NegotiationMessage;
+    try {
+      message = JSON.parse(rawJson);
+    } catch {
+      return { valid: false, error: "SCHEMA_INVALID" };
+    }
+
+    // 3. Required fields
+    if (!message.sig || message.timestamp == null || !message.from) {
+      return { valid: false, error: "SCHEMA_INVALID" };
+    }
+
+    // 4. Timestamp check
+    const now = Math.floor(Date.now() / 1000);
+    const delta = now - message.timestamp;
+    if (Math.abs(delta) > this.opts.timestampToleranceSeconds) {
+      return { valid: false, error: delta < 0 ? "TIMESTAMP_IN_FUTURE" : "TIMESTAMP_TOO_OLD" };
+    }
+
+    // 5. Expiry check (PROPOSE only)
+    if (message.type === "PROPOSE" && message.expiresAt != null && now > message.expiresAt) {
+      return { valid: false, error: "MESSAGE_EXPIRED" };
+    }
+
+    // 6. Signature recovery
+    let recoveredSigner: string;
+    try {
+      const digest = computeMessageDigest(message);
+      recoveredSigner = ethers.recoverAddress(
+        ethers.hashMessage(ethers.getBytes(digest)),
+        message.sig
+      );
+    } catch {
+      return { valid: false, error: "INVALID_SIGNATURE" };
+    }
+
+    // 7. Signer must match from
+    if (recoveredSigner.toLowerCase() !== message.from.toLowerCase()) {
+      return { valid: false, error: "INVALID_SIGNATURE" };
+    }
+
+    // 8. Registry check (fail open on registry downtime)
+    try {
+      const registered = await this.registry.isRegistered(recoveredSigner);
+      if (!registered) {
+        return { valid: false, error: "SIGNER_NOT_REGISTERED" };
+      }
+    } catch {
+      console.warn(
+        "NegotiationGuard: AgentRegistry check failed — proceeding with signature-only verification"
+      );
+    }
+
+    // 9. Nonce replay check
+    const nonceVal =
+      "nonce" in message && message.nonce
+        ? message.nonce
+        : "refNonce" in message && message.refNonce
+        ? message.refNonce
+        : "";
+    const nonceKey = `${message.from.toLowerCase()}:${nonceVal}:${message.timestamp}`;
+    this.pruneNonceCache();
+    if (this.nonceCache.has(nonceKey)) {
+      return { valid: false, error: "NONCE_REPLAYED" };
+    }
+    this.nonceCache.set(nonceKey, Date.now() + this.opts.nonceCacheTtlMs);
+
+    return { valid: true, recoveredSigner: recoveredSigner as any };
+  }
+
+  private pruneNonceCache(): void {
+    const now = Date.now();
+    for (const [key, expiry] of this.nonceCache) {
+      if (now > expiry) this.nonceCache.delete(key);
+    }
+  }
+
+  /** Reset nonce cache (testing / restart) */
+  clearNonceCache(): void {
+    this.nonceCache.clear();
+  }
+}

package/src/negotiation.ts

@@ -0,0 +1,135 @@
+import { ethers } from "ethers";
+import type {
+  NegotiationMessage,
+  NegotiationProposal,
+  NegotiationCounter,
+  NegotiationAccept,
+  NegotiationReject,
+} from "./types";
+
+const MAX_MESSAGE_BYTES = 64 * 1024; // 64KB
+
+// --- Digest computation ---
+// digest = keccak256(abi.encodePacked(type, from, to, nonce, timestamp))
+// nonce is message.nonce (PROPOSE) or message.refNonce (COUNTER/ACCEPT/REJECT) or bytes32(0) if absent
+export function computeMessageDigest(message: NegotiationMessage | (Omit<NegotiationMessage, "sig"> & { sig?: string })): string {
+  const m = message as any;
+  const rawNonce: string = m.nonce || m.refNonce || ethers.ZeroHash;
+  // solidityPackedKeccak256 requires exactly 32 bytes for bytes32 — pad to 32 bytes
+  const nonce = ethers.zeroPadValue(rawNonce, 32);
+
+  return ethers.solidityPackedKeccak256(
+    ["string", "address", "address", "bytes32", "uint256"],
+    [message.type, message.from, message.to, nonce, message.timestamp]
+  );
+}
+
+// --- Signing ---
+
+export async function signNegotiationMessage<T extends NegotiationMessage>(
+  message: Omit<T, "sig">,
+  signer: ethers.Wallet | ethers.Signer
+): Promise<T> {
+  const digest = computeMessageDigest(message as any);
+  const sig = await signer.signMessage(ethers.getBytes(digest));
+  return { ...message, sig } as T;
+}
+
+// --- Signed factory functions ---
+
+export async function createSignedProposal(
+  input: Omit<NegotiationProposal, "type" | "nonce" | "sig" | "timestamp" | "expiresAt"> & {
+    nonce?: string;
+    expiresAt?: number;
+  },
+  signer: ethers.Wallet | ethers.Signer
+): Promise<NegotiationProposal> {
+  const now = Math.floor(Date.now() / 1000);
+  const unsigned: Omit<NegotiationProposal, "sig"> = {
+    type: "PROPOSE",
+    nonce: input.nonce ?? ethers.hexlify(ethers.randomBytes(16)),
+    timestamp: now,
+    expiresAt: input.expiresAt ?? now + 3600,
+    ...input,
+  };
+  return signNegotiationMessage(unsigned, signer);
+}
+
+export async function createSignedCounter(
+  input: Omit<NegotiationCounter, "type" | "sig" | "timestamp">,
+  signer: ethers.Wallet | ethers.Signer
+): Promise<NegotiationCounter> {
+  const unsigned: Omit<NegotiationCounter, "sig"> = {
+    type: "COUNTER",
+    timestamp: Math.floor(Date.now() / 1000),
+    ...input,
+  };
+  return signNegotiationMessage(unsigned, signer);
+}
+
+export async function createSignedAccept(
+  input: Omit<NegotiationAccept, "type" | "sig" | "timestamp">,
+  signer: ethers.Wallet | ethers.Signer
+): Promise<NegotiationAccept> {
+  const unsigned: Omit<NegotiationAccept, "sig"> = {
+    type: "ACCEPT",
+    timestamp: Math.floor(Date.now() / 1000),
+    ...input,
+  };
+  return signNegotiationMessage(unsigned, signer);
+}
+
+export async function createSignedReject(
+  input: Omit<NegotiationReject, "type" | "sig" | "timestamp">,
+  signer: ethers.Wallet | ethers.Signer
+): Promise<NegotiationReject> {
+  const unsigned: Omit<NegotiationReject, "sig"> = {
+    type: "REJECT",
+    timestamp: Math.floor(Date.now() / 1000),
+    ...input,
+  };
+  return signNegotiationMessage(unsigned, signer);
+}
+
+// --- Deprecated unsigned factories (backwards compat) ---
+
+/** @deprecated Use createSignedProposal instead */
+export function createNegotiationProposal(
+  input: Omit<NegotiationProposal, "type" | "nonce" | "sig" | "timestamp" | "expiresAt"> & { nonce?: string }
+): NegotiationProposal {
+  console.warn("createNegotiationProposal: unsigned messages are deprecated. Use createSignedProposal instead.");
+  const now = Math.floor(Date.now() / 1000);
+  return {
+    type: "PROPOSE",
+    nonce: input.nonce ?? ethers.hexlify(ethers.randomBytes(16)),
+    timestamp: now,
+    expiresAt: now + 3600,
+    sig: "0x",
+    ...input,
+  };
+}
+
+/** @deprecated Use createSignedCounter instead */
+export function createNegotiationCounter(input: Omit<NegotiationCounter, "type" | "sig" | "timestamp">): NegotiationCounter {
+  console.warn("createNegotiationCounter: unsigned messages are deprecated. Use createSignedCounter instead.");
+  return { type: "COUNTER", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+
+/** @deprecated Use createSignedAccept instead */
+export function createNegotiationAccept(input: Omit<NegotiationAccept, "type" | "sig" | "timestamp">): NegotiationAccept {
+  console.warn("createNegotiationAccept: unsigned messages are deprecated. Use createSignedAccept instead.");
+  return { type: "ACCEPT", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+
+/** @deprecated Use createSignedReject instead */
+export function createNegotiationReject(input: Omit<NegotiationReject, "type" | "sig" | "timestamp">): NegotiationReject {
+  console.warn("createNegotiationReject: unsigned messages are deprecated. Use createSignedReject instead.");
+  return { type: "REJECT", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+
+export function parseNegotiationMessage(json: string): NegotiationMessage {
+  if (Buffer.byteLength(json, "utf8") > MAX_MESSAGE_BYTES) {
+    throw new Error("NegotiationMessage exceeds 64KB size limit");
+  }
+  return JSON.parse(json) as NegotiationMessage;
+}