@relai-fi/x402 0.5.39 → 0.6.0-rc.1

package/README.md

@@ -340,8 +340,8 @@ import {
   fromAtomicUnits,
 } from '@relai-fi/x402/utils';
 
-// Plugins — extend protect() with free tier, custom logic
-import { freeTier } from '@relai-fi/x402/plugins';
+// Plugins — extend protect() with built-in & custom logic
+import { freeTier, bridge, shield, preflight, circuitBreaker, refund } from '@relai-fi/x402/plugins';
 
 // Management API — create/manage APIs, pricing, analytics, agent bootstrap
 import {
@@ -513,7 +513,20 @@ app.get('/api/solana-data', relai.protect({
 
 ## Plugins
 
-Extend `Relai.protect()` with plugins that run before payment checks. Plugins can skip payment (e.g. free tier), add headers, or attach metadata to requests.
+Extend `Relai.protect()` with plugins that hook into the payment lifecycle. Six built-in plugins ship with the SDK:
+
+```typescript
+import { freeTier, bridge, shield, preflight, circuitBreaker, refund } from '@relai-fi/x402/plugins';
+```
+
+| Plugin | Purpose | Hook |
+|--------|---------|------|
+| **freeTier** | Free API calls before payment | `beforePaymentCheck` → `skip` |
+| **bridge** | Cross-chain payments (Solana ↔ SKALE ↔ Base) | `enrich402Response` |
+| **shield** | Global service health check before payment | `beforePaymentCheck` → `reject` |
+| **preflight** | Per-endpoint liveness probe before payment | `beforePaymentCheck` → `reject` |
+| **circuitBreaker** | Failure history tracking, auto-open circuit | `beforePaymentCheck` → `reject` + `afterSettled` |
+| **refund** | Auto-credit buyers when paid requests fail | `beforePaymentCheck` → `skip` + `afterSettled` |
 
 ### Free Tier Plugin
 
@@ -554,16 +567,15 @@ app.get('/api/data', relai.protect({
 3. If free → `next()` is called without payment, `req.x402Free = true`, and usage is recorded.
 4. If exhausted → normal x402 payment flow continues.
 
-**Free Tier config:**
+**Config:**
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `serviceKey` | `string` | **required** | Your RelAI service key (`sk_live_...`) |
+| `serviceKey` | `string` | — | Your `sk_live_...` key. Omit for local in-memory mode. |
 | `perBuyerLimit` | `number` | **required** | Free calls each buyer gets per period |
-| `resetPeriod` | `'never' \| 'daily' \| 'monthly'` | `'never'` | When counters reset |
+| `resetPeriod` | `'none' \| 'daily' \| 'monthly'` | `'none'` | When counters reset |
 | `globalCap` | `number` | — | Max total free calls across all buyers |
 | `paths` | `string[]` | `['*']` | Which endpoints the free tier applies to |
-| `baseUrl` | `string` | `https://api.relai.fi` | RelAI API URL (override for testing) |
 
 **Request properties set on free-tier bypass:**
 
@@ -574,27 +586,357 @@ app.get('/api/data', relai.protect({
 | `req.x402Plugin` | `string` | Plugin name that granted the bypass (`'freeTier'`) |
 | `req.pluginMeta` | `object` | `{ freeTier: true, remaining: number }` |
 
-**Dashboard:** Manage plugin config and view usage in the RelAI dashboard under **SDK Plugins**.
+### Bridge Plugin
+
+Accept cross-chain payments. Buyers on Solana can pay your SKALE Base API — the SDK handles bridging automatically.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { bridge } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'skale-bite',
+  plugins: [
+    bridge({ serviceKey: process.env.RELAI_SERVICE_KEY }),
+  ],
+});
+```
+
+The plugin auto-discovers bridge capabilities from `/bridge/info`. No manual chain configuration needed.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `serviceKey` | `string` | — | Recommended. Tracks bridge usage in dashboard. |
+| `settleEndpoint` | `string` | `/bridge/settle` | Custom settle endpoint |
+| `feeBps` | `number` | `100` | Bridge fee in basis points (100 = 1%) |
+
+### Shield Plugin
+
+Global service health check — protects buyers from paying for unhealthy endpoints. Before the server returns 402, Shield runs a health check. If unhealthy, returns 503 instead of asking for payment.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { shield } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    shield({
+      healthUrl: 'https://my-api.com/health',
+      timeoutMs: 3000,
+    }),
+    // Or use a custom function:
+    // shield({
+    //   healthCheck: async () => {
+    //     const dbOk = await checkDatabase();
+    //     return dbOk;
+    //   },
+    // }),
+  ],
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `healthUrl` | `string` | — | URL to probe. 2xx = healthy. |
+| `healthCheck` | `() => boolean \| Promise<boolean>` | — | Custom function. Takes priority over `healthUrl`. |
+| `timeoutMs` | `number` | `5000` | Timeout for health probe (ms) |
+| `cacheTtlMs` | `number` | `10000` | Cache health result (ms) |
+| `unhealthyStatus` | `number` | `503` | HTTP status when unhealthy |
+| `unhealthyMessage` | `string` | `Service temporarily unavailable...` | Error message |
+
+**Response headers:** `X-Shield-Status: healthy|unhealthy`, `Retry-After` (when unhealthy).
+
+### Preflight Plugin
+
+Per-endpoint liveness probe — verifies the **specific endpoint** responds before payment. Sends `HEAD` with `X-Preflight: true` header; the middleware responds 200 instantly without triggering payment.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { preflight } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    preflight({ baseUrl: 'https://my-api.com' }),
+  ],
+});
+
+// If /api/data doesn't respond, buyers get 503 — never 402
+app.get('/api/data', relai.protect({
+  payTo: '0xYourWallet',
+  price: 0.01,
+}), handler);
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseUrl` | `string` | **required** | Base URL of the API. Request path is appended automatically. |
+| `timeoutMs` | `number` | `3000` | Timeout for probe (ms) |
+| `cacheTtlMs` | `number` | `5000` | Cache per-path result (ms) |
+| `unhealthyStatus` | `number` | `503` | HTTP status when unreachable |
+| `unhealthyMessage` | `string` | `Endpoint not responding...` | Error message |
+
+**Response headers:** `X-Preflight-Status: ok|unreachable`, `Retry-After` (when unreachable).
+
+**Shield vs Preflight:**
+
+| | Shield | Preflight |
+|---|--------|-----------|
+| Scope | Global service health | Per-endpoint liveness |
+| Probe target | Separate health URL / function | The actual protected endpoint |
+| Cache | Single result (10s) | Per-path (5s) |
+| Use case | DB/Redis/external API down | Specific endpoint not responding |
+
+### Circuit Breaker Plugin
+
+Tracks failure history and automatically "opens the circuit" after repeated failures — preventing buyers from paying for broken endpoints. **Zero-latency** — no extra HTTP requests.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { circuitBreaker } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    circuitBreaker({
+      failureThreshold: 5,  // open after 5 failures
+      resetTimeMs: 30000,   // try again after 30s
+    }),
+  ],
+});
+```
+
+**States:** closed (normal) → open (all rejected 503) → half-open (test requests) → closed.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `failureThreshold` | `number` | `5` | Consecutive failures before circuit opens |
+| `resetTimeMs` | `number` | `30000` | Time (ms) circuit stays open before half-open |
+| `halfOpenSuccesses` | `number` | `2` | Successes needed in half-open to close |
+| `openStatus` | `number` | `503` | HTTP status when circuit is open |
+| `openMessage` | `string` | `Service temporarily unavailable...` | Error message |
+| `failureCodes` | `number[]` | `[500, 502, 503, 504]` | HTTP codes treated as failures |
+| `scope` | `'global' \| 'per-path'` | `'per-path'` | Track globally or per endpoint |
+
+**Response headers:** `X-Circuit-State: closed|open|half-open`, `Retry-After` (when open).
+
+### Refund Plugin
+
+Automatically compensates buyers when paid requests fail. Records an in-memory credit or calls your custom handler.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { refund } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    refund({
+      triggerCodes: [500, 502, 503],
+      mode: 'credit',
+      onRefund: (event) => {
+        console.log(`Refund: $${event.amount} to ${event.payer}`);
+      },
+    }),
+  ],
+});
+```
+
+**Modes:**
+- `credit` — records credit per buyer. Next request skips payment automatically. Header: `X-Refund-Credit: applied`.
+- `log` — only calls `onRefund`. Handle refunds externally (DB, Stripe, etc.).
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `triggerCodes` | `number[]` | `[500, 502, 503, 504]` | HTTP codes that trigger a refund |
+| `mode` | `'credit' \| 'log'` | `'credit'` | Auto-credit or callback-only |
+| `onRefund` | `(event: RefundEvent) => void` | — | Callback on every refund event |
+| `refundOnSettlementFailure` | `boolean` | `true` | Also refund when settlement itself fails |
+
+### ERC-8004 Reputation Plugins
+
+Build verifiable on-chain reputation for your API using the [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) standard. Scores are stored on SKALE Base Sepolia (zero-cost transactions) and readable by any agent before payment.
+
+#### `score()` — Inject reputation into the 402 response
+
+Before an agent pays, it can see your API's live on-chain score in the `extensions.score` field of the 402 response. Fetches directly from the SKALE RPC node — no REST API.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { score } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    score({ agentId: process.env.ERC8004_AGENT_ID! }),
+  ],
+});
+```
+
+The 402 response will include:
+```json
+{
+  "extensions": {
+    "score": {
+      "agentId": "5",
+      "feedbackCount": 142,
+      "successRate": 98.6,
+      "avgResponseMs": 312
+    }
+  }
+}
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `agentId` | `string \| number` | — | ERC-8004 NFT token ID from your dashboard |
+| `rpcUrl` | `string` | `process.env.ERC8004_RPC_URL` | SKALE Base Sepolia RPC URL |
+| `identityRegistryAddress` | `string` | `process.env.ERC8004_IDENTITY_REGISTRY` | IdentityRegistry contract address |
+| `reputationRegistryAddress` | `string` | `process.env.ERC8004_REPUTATION_REGISTRY` | ReputationRegistry contract address |
+| `cacheTtlMs` | `number` | `300000` | Score cache TTL (default: 5 min) |
+
+#### `feedback()` — Record your own API metrics on-chain
+
+Submit `successRate` and `responseTime` after every settled x402 payment. This is what builds the score that `score()` later reads.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { score, feedback } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    score({ agentId: process.env.ERC8004_AGENT_ID! }),
+    feedback({ agentId: process.env.ERC8004_AGENT_ID! }),
+  ],
+});
+```
+
+Requires `BACKEND_WALLET_PRIVATE_KEY` — the wallet must hold CREDIT tokens on SKALE Base for gas.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `agentId` | `string \| number` | — | Your ERC-8004 agent token ID |
+| `walletPrivateKey` | `string` | `process.env.BACKEND_WALLET_PRIVATE_KEY` | EVM private key, needs CREDIT on SKALE |
+| `rpcUrl` | `string` | `process.env.ERC8004_RPC_URL` | SKALE RPC URL |
+| `reputationRegistryAddress` | `string` | `process.env.ERC8004_REPUTATION_REGISTRY` | Contract address |
+| `submitSuccessRate` | `boolean` | `true` | Submit 1/0 success signal |
+| `submitResponseTime` | `boolean` | `true` | Submit response time in ms |
+
+#### `solanaFeedback()` — Native Solana 8004-solana feedback
+
+For Solana APIs registered via `8004-solana` (MPL Core NFT). Requires `npm install 8004-solana`.
+
+```typescript
+import Relai from '@relai-fi/x402/server';
+import { solanaFeedback } from '@relai-fi/x402/plugins';
+
+const relai = new Relai({
+  network: 'solana',
+  plugins: [
+    solanaFeedback({
+      assetPubkey: process.env.SOLANA_AGENT_ASSET!, // MPL Core NFT address
+    }),
+  ],
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `assetPubkey` | `string` | — | Solana MPL Core NFT address (`solanaAgentAsset`) |
+| `feedbackWalletPrivateKey` | `string` | `process.env.SOLANA_8004_FEEDBACK_KEY` | base58 or JSON array |
+| `cluster` | `'mainnet-beta' \| 'devnet'` | `process.env.SOLANA_8004_CLUSTER` | Solana cluster |
+| `rpcUrl` | `string` | `process.env.SOLANA_8004_RPC_URL` | Custom RPC (Helius / QuickNode) |
+
+#### `submitRelayFeedback()` — Third-party feedback utility
+
+If your server acts as a **relay or marketplace** that calls other APIs, use this standalone function to record feedback about those APIs. Uses a separate relay wallet to avoid self-feedback restrictions.
+
+```typescript
+import { submitRelayFeedback } from '@relai-fi/x402/plugins';
+
+// After calling an external API:
+const start = Date.now();
+const result = await fetch('https://other-api.com/v1/data');
+
+submitRelayFeedback({
+  agentId: '5',                        // target API's ERC-8004 agentId
+  success: result.ok,
+  responseTimeMs: Date.now() - start,
+  endpoint: '/v1/data',
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `agentId` | `string \| number` | — | ERC-8004 agentId of the API you called |
+| `success` | `boolean` | — | Whether the call succeeded |
+| `responseTimeMs` | `number` | `0` | Elapsed time in ms |
+| `endpoint` | `string` | `''` | Endpoint path |
+| `feedbackWalletPrivateKey` | `string` | `process.env.FEEDBACK_WALLET_PRIVATE_KEY` | Must differ from API owner key |
+
+#### Required environment variables (ERC-8004)
+
+```bash
+ERC8004_IDENTITY_REGISTRY=0x8724C768547d7fFb1722b13a84F21CCF5010641f
+ERC8004_REPUTATION_REGISTRY=0xe946A7F08d1CC0Ed0eC1fC131D0135d9c0Dd7d9D
+ERC8004_RPC_URL=https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha
+ERC8004_AGENT_ID=5                          # your agent NFT token ID
+
+BACKEND_WALLET_PRIVATE_KEY=0x...            # for feedback() — needs CREDIT on SKALE
+FEEDBACK_WALLET_PRIVATE_KEY=0x...           # for submitRelayFeedback() — different wallet
+
+# Solana 8004 (only if using solanaFeedback)
+SOLANA_AGENT_ASSET=GH93tGR8...             # MPL Core NFT pubkey
+SOLANA_8004_FEEDBACK_KEY=...               # base58 or JSON array
+SOLANA_8004_CLUSTER=mainnet-beta
+SOLANA_8004_RPC_URL=https://...
+```
+
+### Combining Plugins
+
+Plugins run in array order. Combine them for layered protection:
+
+```typescript
+const relai = new Relai({
+  network: 'base',
+  plugins: [
+    shield({ healthUrl: 'https://my-api.com/health' }),  // 1. Is the service up?
+    preflight({ baseUrl: 'https://my-api.com' }),         // 2. Is this endpoint alive?
+    circuitBreaker({ failureThreshold: 5 }),              // 3. Too many recent failures?
+    freeTier({ perBuyerLimit: 5, resetPeriod: 'daily' }), // 4. Free calls left?
+    refund({ triggerCodes: [500, 502, 503] }),             // 5. Compensate on error
+    bridge({ serviceKey: process.env.RELAI_SERVICE_KEY }), // 6. Cross-chain support
+    score({ agentId: process.env.ERC8004_AGENT_ID }),      // 7. Show reputation in 402
+    feedback({ agentId: process.env.ERC8004_AGENT_ID }),   // 8. Record metrics on-chain
+  ],
+});
+```
 
 ### Custom Plugins
 
 ```typescript
-import type { RelaiPlugin } from '@relai-fi/x402';
+import type { RelaiPlugin, PluginContext, PluginResult } from '@relai-fi/x402/plugins';
 
 const myPlugin: RelaiPlugin = {
-  name: 'myPlugin',
-  beforePaymentCheck: async (ctx) => {
-    if (ctx.req.headers['x-vip'] === 'true') {
-      return { skip: true, reason: 'VIP bypass' };
+  name: 'my-plugin',
+
+  async beforePaymentCheck(req, ctx) {
+    if (req.headers['x-vip'] === 'true') {
+      return { skip: true, headers: { 'X-VIP': 'true' } };
     }
     return {};
   },
-};
 
-const relai = new Relai({
-  network: 'base',
-  plugins: [myPlugin],
-});
+  async afterSettled(req, result, ctx) {
+    console.log(`Paid $${ctx.price} by ${result.payer} on ${ctx.network}`);
+  },
+
+  async onInit() {
+    console.log('Plugin initialized');
+  },
+};
 ```
 
 **Plugin interface:**
@@ -602,9 +944,26 @@ const relai = new Relai({
 ```typescript
 interface RelaiPlugin {
   name: string;
-  beforePaymentCheck?: (ctx: PluginContext) => Promise<PluginResult>;
-  afterSettled?: (ctx: PluginContext) => Promise<void>;
-  onInit?: (config: RelaiServerConfig) => Promise<void>;
+  beforePaymentCheck?(req: any, ctx: PluginContext): Promise<PluginResult>;
+  afterSettled?(req: any, result: SettleResult, ctx: PluginContext): Promise<void>;
+  onInit?(): Promise<void>;
+  enrich402Response?(response: any, ctx: PluginContext): any;
+}
+
+interface PluginResult {
+  skip?: boolean;      // Bypass payment, serve content free
+  reject?: boolean;    // Block request entirely (e.g. unhealthy)
+  rejectStatus?: number;
+  rejectMessage?: string;
+  headers?: Record<string, string>;
+  meta?: Record<string, unknown>;
+}
+
+interface PluginContext {
+  network: string;
+  price: number;
+  path: string;
+  method: string;
 }
 ```
 

package/dist/index.cjs

@@ -54,6 +54,7 @@ __export(index_exports, {
   normalizePaymentHeader: () => normalizePaymentHeader,
   resolveToken: () => resolveToken,
   stripePayTo: () => stripePayTo,
+  submitRelayFeedback: () => submitRelayFeedback,
   toAtomicUnits: () => toAtomicUnits
 });
 module.exports = __toCommonJS(index_exports);
@@ -568,6 +569,9 @@ var Relai = class {
     const self = this;
     return async (req, res, next) => {
       try {
+        if (req.headers["x-preflight"] === "true" || req.headers["x-preflight"] === "1") {
+          return res.status(200).json({ status: "ok", preflight: true });
+        }
         const resolvedPrice = typeof options.price === "function" ? await options.price(req) : options.price;
         if (typeof resolvedPrice !== "number" || !isFinite(resolvedPrice) || resolvedPrice <= 0) {
           return res.status(400).json({ error: "Invalid price configuration" });
@@ -630,6 +634,18 @@ var Relai = class {
             if (!plugin.beforePaymentCheck) continue;
             try {
               const pluginResult = await plugin.beforePaymentCheck(req, pluginCtx);
+              if (pluginResult?.reject) {
+                const rejectStatus = pluginResult.rejectStatus || 503;
+                if (pluginResult.headers) {
+                  for (const [k, v] of Object.entries(pluginResult.headers)) {
+                    res.setHeader(k, v);
+                  }
+                }
+                return res.status(rejectStatus).json({
+                  error: pluginResult.rejectMessage || "Service unavailable",
+                  plugin: plugin.name
+                });
+              }
               if (pluginResult?.skip) {
                 if (pluginResult.headers) {
                   for (const [k, v] of Object.entries(pluginResult.headers)) {
@@ -844,12 +860,31 @@ var Relai = class {
             path: req.path || req.originalUrl || "/",
             method: (req.method || "GET").toUpperCase()
           };
-          for (const plugin of self.plugins) {
-            if (!plugin.afterSettled) continue;
-            try {
-              await plugin.afterSettled(req, result, settleCtx);
-            } catch (pluginErr) {
-              console.warn(`[Relai] Plugin '${plugin.name}' afterSettled error (non-blocking):`, pluginErr);
+          const pluginsWithHook = self.plugins.filter((p) => !!p.afterSettled);
+          if (pluginsWithHook.length > 0) {
+            const originalJson = res.json?.bind(res);
+            const originalSend = res.send?.bind(res);
+            const fireAfterSettled = (statusCode) => {
+              const resultWithStatus = { ...result, statusCode };
+              for (const plugin of pluginsWithHook) {
+                plugin.afterSettled(req, resultWithStatus, settleCtx).catch((e) => {
+                  console.warn(`[Relai] Plugin '${plugin.name}' afterSettled error (non-blocking):`, e);
+                });
+              }
+            };
+            if (typeof originalJson === "function") {
+              res.json = function(body) {
+                fireAfterSettled(res.statusCode ?? 200);
+                res.json = originalJson;
+                return originalJson(body);
+              };
+            }
+            if (typeof originalSend === "function") {
+              res.send = function(body) {
+                fireAfterSettled(res.statusCode ?? 200);
+                res.send = originalSend;
+                return originalSend(body);
+              };
             }
           }
         }
@@ -1946,6 +1981,64 @@ function createX402Client(config) {
   return { fetch: x402Fetch };
 }
 
+// src/relay-feedback.ts
+var import_ethers = require("ethers");
+var RELAY_FEEDBACK_REPUTATION_ABI = [
+  "function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash) external"
+];
+function submitRelayFeedback(config) {
+  const agentId = String(config.agentId);
+  const endpoint = config.endpoint ?? "";
+  const responseTimeMs = config.responseTimeMs ?? 0;
+  const privateKey = config.feedbackWalletPrivateKey ?? (typeof process !== "undefined" ? process.env?.FEEDBACK_WALLET_PRIVATE_KEY ?? process.env?.ERC8004_FEEDBACK_WALLET_PRIVATE_KEY : void 0);
+  const reputationAddress = config.reputationRegistryAddress ?? (typeof process !== "undefined" ? process.env?.ERC8004_REPUTATION_REGISTRY : void 0);
+  const rpcUrl = config.rpcUrl ?? (typeof process !== "undefined" ? process.env?.ERC8004_RPC_URL : void 0) ?? "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha";
+  if (!privateKey || !reputationAddress) {
+    console.warn("[relai:submitRelayFeedback] FEEDBACK_WALLET_PRIVATE_KEY or ERC8004_REPUTATION_REGISTRY not set \u2014 skipping");
+    return;
+  }
+  const provider = new import_ethers.ethers.JsonRpcProvider(rpcUrl);
+  const signer = new import_ethers.ethers.Wallet(privateKey, provider);
+  const reputation = new import_ethers.ethers.Contract(reputationAddress, RELAY_FEEDBACK_REPUTATION_ABI, signer);
+  const id = BigInt(agentId);
+  (async () => {
+    const successValue = config.success ? 10000n : 0n;
+    try {
+      const srTx = await reputation.giveFeedback(
+        id,
+        successValue,
+        2,
+        "successRate",
+        "",
+        endpoint,
+        "",
+        import_ethers.ethers.ZeroHash
+      );
+      await srTx.wait();
+      console.log(`[relai:submitRelayFeedback] successRate confirmed agentId=${agentId} success=${config.success}`);
+    } catch (err) {
+      console.warn(`[relai:submitRelayFeedback] successRate failed (non-fatal): ${err?.message}`);
+    }
+    if (responseTimeMs > 0) {
+      try {
+        const rtTx = await reputation.giveFeedback(
+          id,
+          BigInt(Math.max(0, Math.round(responseTimeMs))),
+          0,
+          "responseTime",
+          "",
+          endpoint,
+          "",
+          import_ethers.ethers.ZeroHash
+        );
+        console.log(`[relai:submitRelayFeedback] responseTime sent agentId=${agentId} ms=${responseTimeMs} tx=${rtTx.hash}`);
+      } catch (err) {
+        console.warn(`[relai:submitRelayFeedback] responseTime failed (non-fatal): ${err?.message}`);
+      }
+    }
+  })();
+}
+
 // src/utils/payload-converter.ts
 var NETWORK_V1_TO_V2 = {
   "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
@@ -2120,6 +2213,7 @@ function formatUsd(usd, maxDecimals = 4) {
   normalizePaymentHeader,
   resolveToken,
   stripePayTo,
+  submitRelayFeedback,
   toAtomicUnits
 });
 //# sourceMappingURL=index.cjs.map