agent-escrow 0.1.0

package/src/task.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const crypto = require('crypto');
+const { KINDS, TASK_STATUS, signEvent, publishToRelays, queryRelays, getTag, getTags } = require('./nostr.cjs');
+
+/**
+ * Create a task event template
+ */
+function createTaskEvent(opts) {
+  const {
+    title,
+    description,
+    budget,
+    deadline,
+    capabilities = [],
+    minTrust,
+    lightningAddress,
+    taskId
+  } = opts;
+
+  if (!title) throw new Error('title is required');
+  if (!budget || budget <= 0) throw new Error('budget must be positive');
+
+  const id = taskId || crypto.randomUUID();
+
+  const tags = [
+    ['d', id],
+    ['title', title],
+    ['budget', String(budget)],
+    ['status', TASK_STATUS.OPEN]
+  ];
+
+  if (deadline) tags.push(['deadline', String(Math.floor(deadline / 1000))]);
+  for (const cap of capabilities) tags.push(['c', cap]);
+  if (minTrust) tags.push(['min-trust', String(minTrust)]);
+  if (lightningAddress) tags.push(['ln', lightningAddress]);
+
+  return {
+    kind: KINDS.TASK,
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+    content: description || ''
+  };
+}
+
+/**
+ * Create an updated task event (same d-tag, new status)
+ */
+function updateTaskEvent(originalEvent, updates) {
+  const tags = originalEvent.tags.map(t => {
+    if (t[0] === 'status' && updates.status) return ['status', updates.status];
+    return [...t];
+  });
+
+  // Add worker pubkey on claim
+  if (updates.workerPubkey && !tags.find(t => t[0] === 'p')) {
+    tags.push(['p', updates.workerPubkey]);
+  }
+
+  return {
+    kind: KINDS.TASK,
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+    content: updates.content || originalEvent.content
+  };
+}
+
+/**
+ * Parse a task event into a structured object
+ */
+function parseTask(event) {
+  return {
+    eventId: event.id,
+    taskId: getTag(event, 'd'),
+    poster: event.pubkey,
+    title: getTag(event, 'title'),
+    description: event.content,
+    budget: parseInt(getTag(event, 'budget') || '0', 10),
+    deadline: getTag(event, 'deadline') ? parseInt(getTag(event, 'deadline'), 10) * 1000 : null,
+    status: getTag(event, 'status') || TASK_STATUS.OPEN,
+    capabilities: getTags(event, 'c'),
+    minTrust: getTag(event, 'min-trust') ? parseInt(getTag(event, 'min-trust'), 10) : null,
+    lightningAddress: getTag(event, 'ln'),
+    worker: getTag(event, 'p'),
+    createdAt: event.created_at * 1000,
+    raw: event
+  };
+}
+
+/**
+ * Build filters to find tasks on relays
+ */
+function buildTaskFilters(opts = {}) {
+  const filter = { kinds: [KINDS.TASK] };
+
+  if (opts.status) filter['#status'] = Array.isArray(opts.status) ? opts.status : [opts.status];
+  if (opts.capabilities) filter['#c'] = Array.isArray(opts.capabilities) ? opts.capabilities : [opts.capabilities];
+  if (opts.poster) filter.authors = Array.isArray(opts.poster) ? opts.poster : [opts.poster];
+  if (opts.limit) filter.limit = opts.limit;
+  if (opts.since) filter.since = Math.floor(opts.since / 1000);
+
+  return filter;
+}
+
+/**
+ * Query relays for tasks
+ */
+async function findTasks(relays, opts = {}) {
+  const filter = buildTaskFilters(opts);
+  const events = await queryRelays(relays, filter, opts.timeoutMs);
+
+  let tasks = events.map(parseTask);
+
+  // Client-side filtering for things relays can't filter
+  if (opts.minBudget) tasks = tasks.filter(t => t.budget >= opts.minBudget);
+  if (opts.maxBudget) tasks = tasks.filter(t => t.budget <= opts.maxBudget);
+
+  // Sort by creation time, newest first
+  tasks.sort((a, b) => b.createdAt - a.createdAt);
+
+  return tasks;
+}
+
+/**
+ * Get a specific task by its d-tag (taskId)
+ */
+async function getTask(relays, posterPubkey, taskId, timeoutMs = 8000) {
+  const filter = {
+    kinds: [KINDS.TASK],
+    authors: [posterPubkey],
+    '#d': [taskId]
+  };
+  const events = await queryRelays(relays, filter, timeoutMs);
+  if (events.length === 0) return null;
+
+  // Parameterized replaceable: latest event wins
+  events.sort((a, b) => b.created_at - a.created_at);
+  return parseTask(events[0]);
+}
+
+module.exports = {
+  createTaskEvent,
+  updateTaskEvent,
+  parseTask,
+  buildTaskFilters,
+  findTasks,
+  getTask
+};

package/src/trust.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * Trust integration — optional ai.wot dependency
+ *
+ * Falls back gracefully if ai-wot is not installed.
+ */
+
+let aiWot = null;
+try {
+  aiWot = require('ai-wot');
+} catch (e) {
+  // ai-wot not installed — trust features disabled
+}
+
+/**
+ * Check if trust features are available
+ */
+function trustAvailable() {
+  return aiWot !== null;
+}
+
+/**
+ * Get trust score for a pubkey
+ * Returns null if ai-wot is not installed
+ */
+async function getTrustScore(pubkey, opts = {}) {
+  if (!aiWot) return null;
+
+  try {
+    const relayUrls = opts.relays || ['wss://relay.damus.io', 'wss://nos.lol'];
+    const score = await aiWot.calculateTrustScore(pubkey, { relayUrls });
+    return score;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Check if a pubkey meets minimum trust threshold
+ * Returns true if ai-wot is not installed (permissive default)
+ */
+async function meetsTrustThreshold(pubkey, minScore, opts = {}) {
+  if (!aiWot) return true; // No trust system = trust everyone
+  if (!minScore || minScore <= 0) return true;
+
+  const score = await getTrustScore(pubkey, opts);
+  if (score === null) return true; // Can't check = allow
+  return score.total >= minScore;
+}
+
+/**
+ * Publish a work-completed attestation
+ * Returns null if ai-wot is not installed
+ */
+async function publishWorkAttestation(opts = {}) {
+  if (!aiWot) return null;
+
+  const {
+    targetPubkey,
+    comment,
+    secretKey,
+    relayUrls = ['wss://relay.damus.io', 'wss://nos.lol']
+  } = opts;
+
+  if (!targetPubkey) throw new Error('targetPubkey is required');
+  if (!secretKey) throw new Error('secretKey is required');
+
+  try {
+    const attestation = await aiWot.publishAttestation({
+      targetPubkey,
+      type: 'work-completed',
+      comment: comment || 'Task completed via agent-escrow marketplace',
+      secretKey,
+      relayUrls
+    });
+    return attestation;
+  } catch (e) {
+    // Non-fatal — trust attestation is a bonus, not a requirement
+    return null;
+  }
+}
+
+/**
+ * Publish a negative attestation (for disputes)
+ */
+async function publishDisputeAttestation(opts = {}) {
+  if (!aiWot) return null;
+
+  const {
+    targetPubkey,
+    comment,
+    secretKey,
+    relayUrls = ['wss://relay.damus.io', 'wss://nos.lol']
+  } = opts;
+
+  if (!targetPubkey) throw new Error('targetPubkey is required');
+  if (!secretKey) throw new Error('secretKey is required');
+
+  try {
+    const attestation = await aiWot.publishAttestation({
+      targetPubkey,
+      type: 'service-quality',
+      comment: comment || 'Dispute filed via agent-escrow marketplace',
+      secretKey,
+      relayUrls
+    });
+    return attestation;
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = {
+  trustAvailable,
+  getTrustScore,
+  meetsTrustThreshold,
+  publishWorkAttestation,
+  publishDisputeAttestation
+};