@picoads/eliza-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,1067 @@
+// src/services/picoads.ts
+import crypto from "crypto";
+import { Service } from "@elizaos/core";
+import { privateKeyToAccount } from "viem/accounts";
+import { getAddress } from "viem";
+var PicoadsService = class _PicoadsService extends Service {
+  static serviceType = "PICOADS";
+  capabilityDescription = "Connects to the picoads micro ad network \u2014 handles EIP-191 auth, x402 payments, and marketplace interactions.";
+  apiUrl;
+  account;
+  apiKey = null;
+  _agentId;
+  termsAccepted = false;
+  // Provider caches
+  marketCache = null;
+  stateCache = null;
+  CACHE_TTL_MS = 6e4;
+  get agentId() {
+    return this._agentId;
+  }
+  static async start(runtime) {
+    const service = new _PicoadsService(runtime);
+    await service.initialize(runtime);
+    return service;
+  }
+  async stop() {
+    this.marketCache = null;
+    this.stateCache = null;
+  }
+  async initialize(runtime) {
+    this.apiUrl = runtime.getSetting("PICOADS_API_URL") ?? "https://picoads.xyz";
+    const privateKey = runtime.getSetting("EVM_PRIVATE_KEY");
+    if (!privateKey)
+      throw new Error("EVM_PRIVATE_KEY required in character settings");
+    this.account = privateKeyToAccount(privateKey);
+    this._agentId = getAddress(this.account.address);
+    const memories = await runtime.getMemories({
+      tableName: "picoads_state"
+    });
+    const regMemory = memories?.find(
+      (m) => {
+        const meta = m.content?.metadata;
+        return meta?.type === "registration";
+      }
+    );
+    const regMeta = regMemory?.content?.metadata;
+    if (regMeta?.apiKey) {
+      this.apiKey = regMeta.apiKey;
+      try {
+        const resp = await fetch(
+          `${this.apiUrl}/agents/${this._agentId}/profile`
+        );
+        if (!resp.ok) {
+          this.apiKey = null;
+        }
+      } catch {
+        this.apiKey = null;
+      }
+    }
+  }
+  // --- Registration state ---
+  getRegistrationState() {
+    return { registered: this.apiKey !== null, apiKey: this.apiKey };
+  }
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  hasAcceptedTerms() {
+    return this.termsAccepted;
+  }
+  markTermsAccepted() {
+    this.termsAccepted = true;
+  }
+  // --- Provider caches ---
+  getMarketCache() {
+    if (this.marketCache && Date.now() < this.marketCache.expiresAt) {
+      return this.marketCache.data;
+    }
+    this.marketCache = null;
+    return null;
+  }
+  setMarketCache(data) {
+    this.marketCache = { data, expiresAt: Date.now() + this.CACHE_TTL_MS };
+  }
+  getStateCache() {
+    if (this.stateCache && Date.now() < this.stateCache.expiresAt) {
+      return this.stateCache.data;
+    }
+    this.stateCache = null;
+    return null;
+  }
+  setStateCache(data) {
+    this.stateCache = { data, expiresAt: Date.now() + this.CACHE_TTL_MS };
+  }
+  invalidateStateCache() {
+    this.stateCache = null;
+  }
+  // --- EIP-191 signing ---
+  async signEip191(method, path) {
+    const nonce = crypto.randomBytes(16).toString("hex");
+    const timestamp = Math.floor(Date.now() / 1e3).toString();
+    const message = `picoads:${method}:${path}:${nonce}:${timestamp}`;
+    const signature = await this.account.signMessage({ message });
+    return {
+      header: `EIP191 ${this._agentId}:${nonce}:${timestamp}:${signature}`,
+      nonce,
+      timestamp
+    };
+  }
+  // --- API calls ---
+  async apiCall(method, path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (method !== "GET") {
+      const auth = await this.signEip191(method, path);
+      headers["Authorization"] = auth.header;
+    }
+    let resp = await fetch(`${this.apiUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (resp.status === 429) {
+      const retryAfter = Number(resp.headers.get("retry-after") ?? "5");
+      await new Promise((r) => setTimeout(r, retryAfter * 1e3));
+      if (method !== "GET") {
+        const auth = await this.signEip191(method, path);
+        headers["Authorization"] = auth.header;
+      }
+      resp = await fetch(`${this.apiUrl}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      });
+    }
+    return resp;
+  }
+  // --- x402 payment ---
+  async payX402(endpoint, body) {
+    const probeResp = await this.apiCall("POST", endpoint, body);
+    if (probeResp.status !== 402) {
+      const data = await probeResp.json().catch(() => ({}));
+      return {
+        success: probeResp.ok,
+        data,
+        error: probeResp.ok ? void 0 : data.error
+      };
+    }
+    const paymentRequiredHeader = probeResp.headers.get("payment-required");
+    if (!paymentRequiredHeader) {
+      return { success: false, error: "Got 402 but no PAYMENT-REQUIRED header" };
+    }
+    const paymentRequired = JSON.parse(
+      Buffer.from(paymentRequiredHeader, "base64").toString()
+    );
+    const requirements = paymentRequired.accepts[0];
+    const validAfter = 0;
+    const validBefore = Math.floor(Date.now() / 1e3) + 3600;
+    const nonce = `0x${crypto.randomBytes(32).toString("hex")}`;
+    const domain = {
+      name: requirements.extra?.name ?? "USD Coin",
+      version: requirements.extra?.version ?? "2",
+      chainId: 8453,
+      verifyingContract: requirements.asset
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const typedMessage = {
+      from: this.account.address,
+      to: requirements.payTo,
+      value: BigInt(requirements.amount),
+      validAfter: BigInt(validAfter),
+      validBefore: BigInt(validBefore),
+      nonce
+    };
+    const signature = await this.account.signTypedData({
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message: typedMessage
+    });
+    const paymentPayload = {
+      x402Version: 2,
+      resource: paymentRequired.resource,
+      accepted: requirements,
+      payload: {
+        signature,
+        authorization: {
+          from: this.account.address,
+          to: requirements.payTo,
+          value: requirements.amount,
+          validAfter: validAfter.toString(),
+          validBefore: validBefore.toString(),
+          nonce
+        }
+      }
+    };
+    const paymentSignatureHeader = Buffer.from(
+      JSON.stringify(paymentPayload)
+    ).toString("base64");
+    const auth = await this.signEip191("POST", endpoint);
+    const finalResp = await fetch(`${this.apiUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: auth.header,
+        "PAYMENT-SIGNATURE": paymentSignatureHeader
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const finalData = await finalResp.json().catch(() => ({}));
+    return {
+      success: finalResp.ok,
+      data: finalData,
+      error: finalResp.ok ? void 0 : "Payment failed"
+    };
+  }
+};
+
+// src/actions/register.ts
+var registerAction = {
+  name: "REGISTER_AGENT",
+  description: "Register on picoads to start advertising or publishing. Costs $1 USDC on Base.",
+  similes: [
+    "register on picoads",
+    "sign up for picoads",
+    "create picoads account",
+    "join picoads",
+    "join the ad network"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return false;
+    return !service.getRegistrationState().registered;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const result = await service.payX402("/agents/register", {
+      name: `agent-${service.agentId.slice(0, 8)}`,
+      description: "Eliza agent",
+      wallet: service.agentId,
+      source: "eliza",
+      registrationFile: {
+        name: `agent-${service.agentId.slice(0, 8)}`,
+        description: "Eliza agent"
+      }
+    });
+    if (!result.success) {
+      callback?.({ text: `Registration failed: ${result.error}` });
+      return { success: false, error: `Registration failed: ${result.error}` };
+    }
+    const apiKey = result.data?.apiKey;
+    service.setApiKey(apiKey);
+    await runtime.createMemory(
+      {
+        entityId: runtime.agentId,
+        roomId: message.roomId,
+        content: {
+          text: `Registered on picoads as ${service.agentId}`,
+          metadata: {
+            source: "picoads",
+            type: "registration",
+            agentId: service.agentId,
+            apiKey,
+            registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        unique: true
+      },
+      "picoads_state"
+    );
+    const hubsResp = await service.apiCall("GET", "/hubs");
+    const hubs = hubsResp.ok ? await hubsResp.json() : [];
+    const text = `Registered on picoads as ${service.agentId}. Trust tier 0: $0.05 max match, 1 concurrent delivery. ${hubs.length} active hub(s) available. Use PLACE_ASK to offer your distribution or PLACE_BID to advertise.`;
+    callback?.({ text });
+    service.invalidateStateCache();
+    return { success: true, text };
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "Register me on picoads" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Registering on picoads ($1 USDC)..." }
+      }
+    ]
+  ]
+};
+
+// src/actions/place-bid.ts
+var placeBidAction = {
+  name: "PLACE_BID",
+  description: "Post an advertising bid in a picoads hub. You specify what outcome you want (e.g. 'click', 'impression'), your budget, unit price, targeting, and creative. If a matching publisher ask exists, you'll be matched automatically.",
+  similes: [
+    "place a bid",
+    "advertise on picoads",
+    "post a bid",
+    "buy ads",
+    "create an ad campaign"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    if (!service.getRegistrationState().registered) {
+      return { success: false, error: "Not registered. Use REGISTER_AGENT first." };
+    }
+    const hubId = options?.hubId;
+    const objective = options?.objective;
+    const budget = options?.budget;
+    const unitPrice = options?.unitPrice;
+    const targeting = options?.targeting;
+    const creative = options?.creative;
+    const callbackUrl = options?.callbackUrl;
+    if (!hubId || !objective || !budget || !unitPrice) {
+      callback?.({
+        text: "I need: hubId, objective (e.g. 'click'), budget (total USDC), and unitPrice (per unit USDC). Check available hubs first."
+      });
+      return {
+        success: false,
+        error: "Missing required fields: hubId, objective, budget, unitPrice"
+      };
+    }
+    const needsTerms = !service.hasAcceptedTerms();
+    const body = {
+      agentId: service.agentId,
+      objective,
+      budget,
+      unitPrice,
+      settlementChain: "base",
+      settlementWallet: service.agentId,
+      ...targeting && { targeting },
+      ...creative && { creative },
+      ...callbackUrl && { callbackUrl },
+      ...needsTerms && { termsAccepted: true }
+    };
+    const resp = await service.apiCall("POST", `/hubs/${hubId}/bids`, body);
+    const data = await resp.json();
+    if (!resp.ok) {
+      callback?.({ text: `Bid failed: ${data.error ?? resp.statusText}` });
+      return { success: false, error: data.error };
+    }
+    if (needsTerms) service.markTermsAccepted();
+    service.invalidateStateCache();
+    const status = data.status === "matched" ? " -- MATCHED with a publisher!" : " (status: open)";
+    const text = `Bid placed in hub ${hubId}${status}. Budget: $${budget}, unit price: $${unitPrice}/${objective}.`;
+    callback?.({ text });
+    return { success: true, text, data };
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "I want to advertise my DeFi protocol in the defi-yield hub at $0.05 per click with a $5 budget" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Placing a bid in defi-yield: $5 budget, $0.05/click..." }
+      }
+    ]
+  ]
+};
+
+// src/actions/place-ask.ts
+var placeAskAction = {
+  name: "PLACE_ASK",
+  description: "Post a publishing ask in a picoads hub. You specify your inventory (e.g. 'newsletter slot'), floor price, audience details, and accepted formats. If a matching advertiser bid exists, you'll be matched automatically.",
+  similes: [
+    "place an ask",
+    "offer distribution",
+    "post an ask",
+    "sell ad space",
+    "offer inventory",
+    "publish on picoads"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    if (!service.getRegistrationState().registered) {
+      return { success: false, error: "Not registered. Use REGISTER_AGENT first." };
+    }
+    const hubId = options?.hubId;
+    const inventory = options?.inventory;
+    const floorPrice = options?.floorPrice;
+    const audience = options?.audience;
+    const formats = options?.formats;
+    const autoRenew = options?.autoRenew;
+    const callbackUrl = options?.callbackUrl;
+    if (!hubId || !inventory || !floorPrice) {
+      callback?.({
+        text: "I need: hubId, inventory (description of your ad space), and floorPrice (minimum USDC per unit)."
+      });
+      return {
+        success: false,
+        error: "Missing required fields: hubId, inventory, floorPrice"
+      };
+    }
+    const needsTerms = !service.hasAcceptedTerms();
+    const body = {
+      agentId: service.agentId,
+      inventory,
+      floorPrice,
+      settlementChain: "base",
+      settlementWallet: service.agentId,
+      formats: formats ?? ["text", "link"],
+      ...audience && { audience },
+      ...autoRenew !== void 0 && { autoRenew },
+      ...callbackUrl && { callbackUrl },
+      ...needsTerms && { termsAccepted: true }
+    };
+    const resp = await service.apiCall("POST", `/hubs/${hubId}/asks`, body);
+    const data = await resp.json();
+    if (!resp.ok) {
+      callback?.({ text: `Ask failed: ${data.error ?? resp.statusText}` });
+      return { success: false, error: data.error };
+    }
+    if (needsTerms) service.markTermsAccepted();
+    service.invalidateStateCache();
+    const status = data.status === "matched" ? " -- MATCHED with an advertiser!" : " (status: open)";
+    const text = `Ask placed in hub ${hubId}${status}. Inventory: ${inventory}, floor: $${floorPrice}.`;
+    callback?.({ text });
+    return { success: true, text, data };
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "I want to sell a newsletter slot in the defi-yield hub at $0.03 floor" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Placing an ask in defi-yield: newsletter slot at $0.03 floor..." }
+      }
+    ]
+  ]
+};
+
+// src/actions/check-matches.ts
+var checkMatchesAction = {
+  name: "CHECK_MATCHES",
+  description: "Check your current matches on picoads. Shows pending deliveries, delivered matches awaiting confirmation, and settled matches.",
+  similes: [
+    "check matches",
+    "my matches",
+    "match status",
+    "see my matches",
+    "what's matched"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const statusFilter = options?.status;
+    const resp = await service.apiCall("GET", `/agents/${service.agentId}/matches`);
+    if (!resp.ok) {
+      return { success: false, error: "Failed to fetch matches" };
+    }
+    const matches = await resp.json();
+    const filtered = statusFilter ? matches.filter((m) => m.status === statusFilter) : matches;
+    if (filtered.length === 0) {
+      const text2 = statusFilter ? `No matches with status '${statusFilter}'.` : "No matches found.";
+      callback?.({ text: text2 });
+      return { success: true, text: text2 };
+    }
+    const byStatus = {};
+    for (const m of filtered) {
+      const s = m.status;
+      (byStatus[s] ??= []).push(m);
+    }
+    const lines = [];
+    for (const [status, group] of Object.entries(byStatus)) {
+      lines.push(`${status}: ${group.length} match(es)`);
+      for (const m of group.slice(0, 5)) {
+        let detail = `  - ${m.id.slice(0, 12)}... hub: ${m.hubId}, price: $${m.agreedPrice}`;
+        const v = m.verification;
+        if (v?.status) detail += ` (${v.status})`;
+        if (m.disputedBy) detail += ` [disputed by: ${m.disputedBy}]`;
+        lines.push(detail);
+      }
+      if (group.length > 5) lines.push(`  ... and ${group.length - 5} more`);
+    }
+    const text = `Your matches:
+${lines.join("\n")}`;
+    callback?.({ text });
+    return { success: true, text, data: { matches: filtered } };
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "Show me my picoads matches" } },
+      { name: "assistant", content: { text: "Checking your matches..." } }
+    ]
+  ]
+};
+
+// src/actions/fetch-creative.ts
+var fetchCreativeAction = {
+  name: "FETCH_CREATIVE",
+  description: "Fetch the ad creative for a matched bid so you can deliver it. Only relevant for publishers with pending delivery matches.",
+  similes: [
+    "fetch creative",
+    "get ad creative",
+    "get the ad",
+    "what should I publish",
+    "download creative"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const matchId = options?.matchId;
+    let targetMatchId = matchId;
+    if (!targetMatchId) {
+      const resp2 = await service.apiCall(
+        "GET",
+        `/agents/${service.agentId}/matches`
+      );
+      if (resp2.ok) {
+        const matches = await resp2.json();
+        const pending = matches.find((m) => m.status === "pending_delivery");
+        if (pending) targetMatchId = pending.id;
+      }
+    }
+    if (!targetMatchId) {
+      callback?.({ text: "No pending deliveries found. Nothing to fetch." });
+      return { success: false, error: "No pending deliveries" };
+    }
+    const resp = await service.apiCall("GET", `/matches/${targetMatchId}`);
+    if (!resp.ok) {
+      return { success: false, error: "Failed to fetch match details" };
+    }
+    const match = await resp.json();
+    const creative = match.creative;
+    const lines = [`Match: ${targetMatchId}`, `Hub: ${match.hubId}`, `Price: $${match.agreedPrice}`];
+    if (creative) {
+      if (creative.headline) lines.push(`Headline: ${creative.headline}`);
+      if (creative.body) lines.push(`Body: ${creative.body}`);
+      if (creative.cta) lines.push(`CTA: ${creative.cta}`);
+      if (creative.url) lines.push(`URL: ${creative.url}`);
+    } else {
+      lines.push("No creative details attached to this bid.");
+    }
+    const text = lines.join("\n");
+    callback?.({ text });
+    return { success: true, text, data: { matchId: targetMatchId, creative } };
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "What ad should I deliver?" } },
+      { name: "assistant", content: { text: "Fetching creative for your pending delivery..." } }
+    ]
+  ]
+};
+
+// src/actions/deliver.ts
+var deliverAction = {
+  name: "DELIVER_AD",
+  description: "Report delivery of an ad for a matched ask. Provide proof of delivery (e.g. where it was published, screenshot URL). Self-reported proof is accepted but won't count toward tier advancement. Use url-verified (include a URL) for verified deliveries that build trust.",
+  similes: [
+    "deliver ad",
+    "report delivery",
+    "I delivered the ad",
+    "submit proof",
+    "mark as delivered"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    let matchId = options?.matchId;
+    const proofType = options?.proofType ?? "self-reported";
+    const evidence = options?.evidence;
+    if (!matchId) {
+      const resp2 = await service.apiCall(
+        "GET",
+        `/agents/${service.agentId}/matches`
+      );
+      if (resp2.ok) {
+        const matches = await resp2.json();
+        const pending = matches.find((m) => m.status === "pending_delivery");
+        if (pending) matchId = pending.id;
+      }
+    }
+    if (!matchId) {
+      callback?.({ text: "No pending deliveries found." });
+      return { success: false, error: "No pending deliveries" };
+    }
+    const proof = {
+      type: proofType,
+      evidence: typeof evidence === "string" ? { description: evidence, deliveredAt: (/* @__PURE__ */ new Date()).toISOString() } : evidence ?? { description: "Ad delivered via Eliza agent", deliveredAt: (/* @__PURE__ */ new Date()).toISOString() },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const resp = await service.apiCall("POST", `/matches/${matchId}/delivery`, {
+      reportedBy: service.agentId,
+      proof
+    });
+    const data = await resp.json();
+    if (!resp.ok) {
+      const error = data.error;
+      callback?.({ text: `Delivery report failed: ${error}` });
+      return { success: false, error };
+    }
+    service.invalidateStateCache();
+    const verification = data.verification;
+    const vStatus = verification?.status;
+    let text;
+    if (vStatus === "failed") {
+      const reason = verification?.failureReason ?? "unknown";
+      text = `Delivery proof failed verification (${reason}). Match disputed. No settlement created.`;
+    } else if (vStatus === "verified") {
+      text = `Delivery verified (${verification?.method}). Awaiting human review. Settlement created.`;
+    } else {
+      text = `Delivery recorded (unverified). Awaiting human review. Settlement created.`;
+    }
+    text += ` Match: ${matchId}.`;
+    callback?.({ text });
+    return { success: !!(vStatus !== "failed"), text, data };
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "I published the ad in my newsletter, report delivery" }
+      },
+      {
+        name: "assistant",
+        content: { text: "Reporting delivery with self-reported proof..." }
+      }
+    ]
+  ]
+};
+
+// src/actions/confirm.ts
+var confirmDeliveryAction = {
+  name: "CONFIRM_DELIVERY",
+  description: "Confirm or dispute a delivery as an advertiser. If the publisher delivered your ad correctly, confirm it to trigger settlement. If not, dispute with a reason.",
+  similes: [
+    "confirm delivery",
+    "approve delivery",
+    "verify delivery",
+    "dispute delivery",
+    "reject delivery"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const matchId = options?.matchId;
+    const confirmed = options?.confirmed ?? true;
+    const disputeReason = options?.disputeReason;
+    if (!matchId) {
+      const resp = await service.apiCall(
+        "GET",
+        `/agents/${service.agentId}/matches`
+      );
+      if (resp.ok) {
+        const matches = await resp.json();
+        const delivered = matches.find((m) => m.status === "delivered");
+        if (delivered) {
+          return handleConfirmation(service, delivered.id, confirmed, disputeReason, callback);
+        }
+      }
+      callback?.({ text: "No delivered matches awaiting confirmation." });
+      return { success: false, error: "No delivered matches found" };
+    }
+    return handleConfirmation(service, matchId, confirmed, disputeReason, callback);
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "Confirm the delivery looks good" } },
+      { name: "assistant", content: { text: "Confirming delivery..." } }
+    ]
+  ]
+};
+async function handleConfirmation(service, matchId, confirmed, disputeReason, callback) {
+  if (!confirmed && disputeReason) {
+    const resp2 = await service.apiCall("POST", `/matches/${matchId}/dispute`, {
+      agentId: service.agentId,
+      reason: disputeReason
+    });
+    const data2 = await resp2.json();
+    if (!resp2.ok) {
+      callback?.({ text: `Dispute failed: ${data2.error}` });
+      return { success: false, error: data2.error };
+    }
+    service.invalidateStateCache();
+    const text2 = `Delivery disputed for match ${matchId}. Reason: ${disputeReason}.`;
+    callback?.({ text: text2 });
+    return { success: true, text: text2, data: data2 };
+  }
+  const resp = await service.apiCall(
+    "POST",
+    `/matches/${matchId}/confirm-delivery`,
+    {
+      agentId: service.agentId,
+      confirmed: true
+    }
+  );
+  const data = await resp.json();
+  if (!resp.ok) {
+    callback?.({ text: `Confirmation failed: ${data.error}` });
+    return { success: false, error: data.error };
+  }
+  service.invalidateStateCache();
+  const text = `Delivery confirmed for match ${matchId}. Settlement will be created.`;
+  callback?.({ text });
+  return { success: true, text, data };
+}
+
+// src/actions/settle.ts
+var paySettlementAction = {
+  name: "PAY_SETTLEMENT",
+  description: "Pay pending settlements on picoads. Settlements are created after delivery confirmation. Payment uses x402 (USDC on Base). This action pays all pending settlements.",
+  similes: [
+    "pay settlement",
+    "settle up",
+    "pay what I owe",
+    "make payment",
+    "pay picoads bill"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const resp = await service.apiCall(
+      "GET",
+      `/agents/${service.agentId}/pending-settlements`
+    );
+    if (!resp.ok) {
+      return { success: false, error: "Failed to fetch pending settlements" };
+    }
+    const settlements = await resp.json();
+    const pending = settlements.filter((s) => s.status === "pending");
+    if (pending.length === 0) {
+      callback?.({ text: "No pending settlements." });
+      return { success: true, text: "No pending settlements." };
+    }
+    const results = [];
+    let paid = 0;
+    let failed = 0;
+    for (const s of pending) {
+      const result = await service.payX402(
+        `/settlements/${s.id}/pay`
+      );
+      if (result.success) {
+        const txHash = result.data?.txHash;
+        results.push(
+          `Paid $${s.grossAmount} for settlement ${s.id.slice(0, 12)}...${txHash ? ` (tx: ${txHash.slice(0, 12)}...)` : ""}`
+        );
+        paid++;
+      } else {
+        results.push(
+          `Failed to pay settlement ${s.id.slice(0, 12)}...: ${result.error}`
+        );
+        failed++;
+      }
+    }
+    service.invalidateStateCache();
+    const text = `Settlement results: ${paid} paid, ${failed} failed.
+${results.join("\n")}`;
+    callback?.({ text });
+    return { success: true, text, data: { paid, failed } };
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "Pay my picoads settlements" } },
+      { name: "assistant", content: { text: "Paying pending settlements..." } }
+    ]
+  ]
+};
+
+// src/actions/reputation.ts
+var checkReputationAction = {
+  name: "CHECK_REPUTATION",
+  description: "Check your trust tier, reputation score, and progress toward the next tier on picoads. Shows constraints (max match price, concurrent deliveries, settlement cap) and what you need to advance.",
+  similes: [
+    "check reputation",
+    "my trust tier",
+    "reputation status",
+    "trust level",
+    "tier progress"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const resp = await service.apiCall(
+      "GET",
+      `/agents/${service.agentId}/reputation`
+    );
+    if (!resp.ok) {
+      return { success: false, error: "Failed to fetch reputation" };
+    }
+    const rep = await resp.json();
+    const lines = [
+      `Trust tier: ${rep.trustTier ?? 0} (${rep.trustTierName ?? "unproven"})`,
+      `Max match price: $${rep.maxMatchPrice ?? 0.05}`,
+      `Max concurrent deliveries: ${rep.maxConcurrentDeliveries ?? 1}`,
+      `Pending settlement cap: $${rep.pendingSettlementCap ?? 1}`
+    ];
+    if (rep.tierProgress) {
+      const progress = rep.tierProgress;
+      lines.push(`
+Progress to next tier:`);
+      if (progress.verifiedDeliveries !== void 0)
+        lines.push(`  Verified deliveries: ${progress.verifiedDeliveries}/${progress.requiredVerified ?? 3}`);
+      if (progress.confirmedDeliveries !== void 0)
+        lines.push(`  Confirmed deliveries: ${progress.confirmedDeliveries}/${progress.requiredDeliveries ?? 5}`);
+      if (progress.distinctPartners !== void 0)
+        lines.push(`  Distinct partners: ${progress.distinctPartners}/${progress.requiredPartners ?? 2}`);
+      if (progress.daysSinceRegistration !== void 0)
+        lines.push(`  Days since registration: ${progress.daysSinceRegistration}/${progress.requiredDays ?? 7}`);
+      if (progress.disputeRate !== void 0)
+        lines.push(`  Dispute rate: ${(progress.disputeRate * 100).toFixed(0)}% (max ${(progress.maxDisputeRate ?? 0.2) * 100}%)`);
+    }
+    const text = lines.join("\n");
+    callback?.({ text });
+    return { success: true, text, data: rep };
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "What's my picoads trust tier?" } },
+      { name: "assistant", content: { text: "Checking your reputation..." } }
+    ]
+  ]
+};
+
+// src/actions/action-items.ts
+var checkActionItemsAction = {
+  name: "CHECK_ACTION_ITEMS",
+  description: "Check what needs your attention on picoads. Shows pending deliveries, unconfirmed matches, unpaid settlements, and other action items ranked by urgency.",
+  similes: [
+    "check action items",
+    "what needs attention",
+    "picoads todo",
+    "what should I do next",
+    "pending tasks"
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("PICOADS");
+    return !!service?.getRegistrationState().registered;
+  },
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { success: false, error: "PicoadsService not available" };
+    const [matchesResp, settlementsResp] = await Promise.all([
+      service.apiCall("GET", `/agents/${service.agentId}/matches`),
+      service.apiCall("GET", `/agents/${service.agentId}/pending-settlements`)
+    ]);
+    const matches = matchesResp.ok ? await matchesResp.json() : [];
+    const settlements = settlementsResp.ok ? await settlementsResp.json() : [];
+    const pendingDelivery = matches.filter((m) => m.status === "pending_delivery");
+    const delivered = matches.filter((m) => m.status === "delivered");
+    const pendingSettlements = settlements.filter((s) => s.status === "pending");
+    const items = [];
+    if (pendingDelivery.length > 0) {
+      items.push(
+        `[URGENT] ${pendingDelivery.length} pending delivery(ies) \u2014 use FETCH_CREATIVE then DELIVER_AD`
+      );
+    }
+    if (delivered.length > 0) {
+      items.push(
+        `[ACTION] ${delivered.length} delivery(ies) awaiting your confirmation \u2014 use CONFIRM_DELIVERY`
+      );
+    }
+    if (pendingSettlements.length > 0) {
+      const totalOwed = pendingSettlements.reduce(
+        (sum, s) => sum + s.grossAmount,
+        0
+      );
+      items.push(
+        `[ACTION] ${pendingSettlements.length} unpaid settlement(s) totaling $${totalOwed.toFixed(2)} \u2014 use PAY_SETTLEMENT`
+      );
+    }
+    if (items.length === 0) {
+      const text2 = "No action items. You're all caught up!";
+      callback?.({ text: text2 });
+      return { success: true, text: text2 };
+    }
+    const text = `Action items:
+${items.map((item, i) => `${i + 1}. ${item}`).join("\n")}`;
+    callback?.({ text });
+    return {
+      success: true,
+      text,
+      data: {
+        pendingDeliveries: pendingDelivery.length,
+        awaitingConfirmation: delivered.length,
+        unpaidSettlements: pendingSettlements.length
+      }
+    };
+  },
+  examples: [
+    [
+      { name: "user", content: { text: "What needs my attention on picoads?" } },
+      { name: "assistant", content: { text: "Checking your action items..." } }
+    ]
+  ]
+};
+
+// src/providers/market.ts
+var marketProvider = {
+  name: "PICOADS_MARKET",
+  description: "Current picoads marketplace state \u2014 active hubs, open bids/asks, pricing data",
+  dynamic: true,
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { text: "" };
+    const cached = service.getMarketCache();
+    if (cached) return { text: cached };
+    try {
+      const hubsResp = await service.apiCall("GET", "/hubs?status=active");
+      const hubs = hubsResp.ok ? await hubsResp.json() : [];
+      if (hubs.length === 0) {
+        const text2 = "picoads marketplace: no active hubs found.";
+        service.setMarketCache(text2);
+        return { text: text2 };
+      }
+      const hubSummaries = [];
+      for (const hub of hubs.slice(0, 5)) {
+        const hubId = hub.id ?? hub.slug;
+        const [statsResp, bidsResp] = await Promise.all([
+          service.apiCall("GET", `/hubs/${hubId}/market-stats`),
+          service.apiCall("GET", `/hubs/${hubId}/bids?limit=5`)
+        ]);
+        const stats = statsResp.ok ? await statsResp.json() : {};
+        const bids = bidsResp.ok ? await bidsResp.json() : [];
+        const bidSummary = bids.map(
+          (b) => `$${b.unitPrice}/${b.objective} (budget: $${b.remainingBudget})`
+        ).join(", ");
+        hubSummaries.push(
+          `${hub.name ?? hubId}: ${stats.openBids ?? 0} open bids, ${stats.openAsks ?? 0} open asks. ` + (bidSummary ? `Top bids: ${bidSummary}. ` : "") + `Fill rate: ${stats.askFillRate ?? "N/A"}.`
+        );
+      }
+      const text = `picoads marketplace:
+${hubSummaries.join("\n")}`;
+      service.setMarketCache(text);
+      return { text };
+    } catch {
+      return { text: "picoads marketplace: unable to fetch market data." };
+    }
+  }
+};
+
+// src/providers/agent-state.ts
+var agentStateProvider = {
+  name: "PICOADS_AGENT_STATE",
+  description: "Your picoads registration, reputation, and pending actions",
+  dynamic: true,
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService("PICOADS");
+    if (!service) return { text: "" };
+    const cached = service.getStateCache();
+    if (cached) return { text: cached };
+    const regState = service.getRegistrationState();
+    if (!regState.registered) {
+      const text = "Not registered on picoads. Use REGISTER_AGENT to register ($1 USDC on Base).";
+      return { text };
+    }
+    try {
+      const [repResp, matchResp, settResp] = await Promise.all([
+        service.apiCall("GET", `/agents/${service.agentId}/reputation`),
+        service.apiCall("GET", `/agents/${service.agentId}/matches`),
+        service.apiCall("GET", `/agents/${service.agentId}/pending-settlements`)
+      ]);
+      const rep = repResp.ok ? await repResp.json() : {};
+      const matches = matchResp.ok ? await matchResp.json() : [];
+      const settlements = settResp.ok ? await settResp.json() : [];
+      const pending = matches.filter((m) => m.status === "pending_delivery");
+      const delivered = matches.filter((m) => m.status === "delivered");
+      let text = "picoads agent state:\n";
+      text += `Trust tier: ${rep.trustTier ?? 0} (${rep.trustTierName ?? "unproven"}). `;
+      text += `Max match: $${rep.maxMatchPrice ?? 0.05}. `;
+      text += `${pending.length} pending deliveries. `;
+      text += `${delivered.length} awaiting confirmation. `;
+      text += `${settlements.length} unpaid settlements ($${settlements.reduce((s, x) => s + (x.grossAmount ?? 0), 0).toFixed(2)} owed).`;
+      if (pending.length > 0) {
+        text += `
+ACTION NEEDED: You have ${pending.length} pending delivery(ies). Use FETCH_CREATIVE then DELIVER_AD.`;
+      }
+      if (settlements.length > 0) {
+        text += `
+ACTION NEEDED: You have ${settlements.length} unpaid settlement(s). Use PAY_SETTLEMENT.`;
+      }
+      service.setStateCache(text);
+      return { text };
+    } catch {
+      return { text: "picoads agent state: unable to fetch state data." };
+    }
+  }
+};
+
+// src/index.ts
+var picoadsPlugin = {
+  name: "@picoads/eliza-plugin",
+  description: "Connects Eliza agents to picoads \u2014 the micro ad network for AI agents. Handles registration, bidding, asking, delivery, settlement, and reputation tracking.",
+  services: [PicoadsService],
+  actions: [
+    registerAction,
+    placeBidAction,
+    placeAskAction,
+    checkMatchesAction,
+    fetchCreativeAction,
+    deliverAction,
+    confirmDeliveryAction,
+    paySettlementAction,
+    checkReputationAction,
+    checkActionItemsAction
+  ],
+  providers: [marketProvider, agentStateProvider]
+};
+var index_default = picoadsPlugin;
+export {
+  PicoadsService,
+  agentStateProvider,
+  checkActionItemsAction,
+  checkMatchesAction,
+  checkReputationAction,
+  confirmDeliveryAction,
+  index_default as default,
+  deliverAction,
+  fetchCreativeAction,
+  marketProvider,
+  paySettlementAction,
+  picoadsPlugin,
+  placeAskAction,
+  placeBidAction,
+  registerAction
+};
+//# sourceMappingURL=index.js.map