paygate 4.0.0 → 4.0.1

package/README.md

@@ -1,8 +1,8 @@
 # paygate
 
-Gate your API with USDC micropayments in one line of code. AI agents pay per-request using the [x402 protocol](https://x402.org) — **no accounts, no API keys, no subscriptions needed.**
+Accept agent payments on an existing API with HTTP 402 and USDC settlement. PayGate handles the x402 challenge, calls the ArisPay facilitator, and lets your handler run only after payment settles.
 
-Works with Express and Fastify. Settlement and gas sponsorship handled by ArisPay.
+Use the hosted proxy for zero-code acceptance, or install this package when you want the 402 flow on your own domain.
 
 ## Install
 
@@ -17,16 +17,19 @@ import express from 'express';
 import { paygate } from 'paygate/express';
 
 const app = express();
-const pw = paygate({ wallet: '0xYourUSDCWallet' });
+
+const pw = paygate({
+  merchantId: process.env.PAYGATE_MERCHANT_ID,
+});
 
 // $0.10 per request
-app.get('/api/data', pw({ price: 0.10 }), (req, res) => {
+app.get('/api/data', pw({ priceCents: 10 }), (req, res) => {
   res.json({ data: 'premium content' });
 });
 
 // Dynamic pricing
 app.post('/api/analyze', pw({
-  price: (req) => req.body.depth === 'deep' ? 0.50 : 0.10,
+  priceCents: (req) => req.body.depth === 'deep' ? 50 : 10,
   description: 'AI analysis',
 }), (req, res) => {
   res.json({ result: '...' });
@@ -43,18 +46,23 @@ import paygate from 'paygate/fastify';
 
 const app = Fastify();
 
-await app.register(paygate, { wallet: '0xYourUSDCWallet' });
+await app.register(paygate, {
+  merchantId: process.env.PAYGATE_MERCHANT_ID,
+});
 
-// Auto-paywall via route config
+// Route-config-driven paywall
 app.get('/api/data', {
-  config: { x402: { price: 0.10 } }
+  config: { paygate: { priceCents: 10 } },
 }, async (req, reply) => {
   reply.send({ data: 'premium content' });
 });
 
 // Or imperative API
 app.get('/api/research', async (req, reply) => {
-  const { paid } = await req.x402Pay({ price: 0.05, description: 'Research query' });
+  const { paid } = await req.paygatePay({
+    priceCents: 5,
+    description: 'Research query',
+  });
   if (!paid) return; // 402 challenge already sent
   reply.send({ results: '...' });
 });
@@ -62,65 +70,73 @@ app.get('/api/research', async (req, reply) => {
 await app.listen({ port: 3000 });
 ```
 
+## Hosted proxy
+
+For a no-code merchant integration:
+
+1. Register at `https://paygate.arispay.app/merchant-register`.
+2. Add a primary USDC payout wallet in the PayGate dashboard.
+3. Add a product with `method`, `path`, `targetUrl`, and `priceCents`.
+4. Agents call `https://paygate.arispay.app/{slug}{path}`.
+
+Example agent test:
+
+```bash
+npx payagent pay https://paygate.arispay.app/acme/forecast?city=London
+```
+
+API equivalent for product creation:
+
+```bash
+curl -X POST https://api.arispay.app/v1/merchants/me/products \
+  -H 'authorization: Bearer mp_live_…' \
+  -H 'content-type: application/json' \
+  -d '{
+    "method": "GET",
+    "path": "/forecast",
+    "targetUrl": "https://api.acme.com/v1/forecast",
+    "priceCents": 2,
+    "description": "Weather forecast"
+  }'
+```
+
 ## How it works
 
 ```
-Agent                    Your API              ArisPay Facilitator
+Agent                    Your API / Proxy       ArisPay Facilitator
   │                         │                        │
   ├─── GET /api/data ──────►│                        │
-  │                         │  (no X-Payment header) │
+  │                         │  no X-Payment header   │
   │◄── 402 + requirements ──┤                        │
   │                         │                        │
-  │   (agent signs EIP-3009 USDC transfer)           │
+  │   agent signs USDC transfer authorization        │
   │                         │                        │
   ├─── GET /api/data ──────►│                        │
   │    + X-Payment header   ├── POST /settle ────────►│
   │                         │                        │ verify + settle
-  │                         │◄── { success, txHash } ─┤ sponsor gas
+  │                         │◄── { success, txHash } ─┤
   │◄── 200 + data ──────────┤                        │
 ```
 
-The agent SDKs ([payagent](https://npmjs.com/package/payagent)) handle the signing automatically — agents don't need to understand the protocol.
+The agent-side [`payagent`](https://www.npmjs.com/package/payagent) CLI and SDK handle the 402 loop automatically.
 
 ## Config
 
 | Option | Required | Default | Description |
 |---|---|---|---|
-| `wallet` | Yes | — | Your USDC wallet address |
-| `network` | No | `eip155:84532` | CAIP-2 network ID (Base Sepolia testnet) |
-| `asset` | No | Auto | USDC contract address |
-| `facilitatorUrl` | No | ArisPay production | Override the settlement facilitator |
-| `timeout` | No | `30000` | Facilitator call timeout (ms) |
-
-## Networks
-
-| Network | ID | Status |
-|---|---|---|
-| Base Sepolia | `eip155:84532` | **Default (testnet)** |
-| Base Mainnet | `eip155:8453` | Production |
-| Ethereum | `eip155:1` | Production |
-| Polygon | `eip155:137` | Production |
-
-## Agent-side
-
-Agents use [payagent](https://npmjs.com/package/payagent) — a drop-in fetch wrapper that handles 402 payments automatically:
+| `merchantId` | Yes | — | PayGate merchant ID from the dashboard. The SDK fetches payout rail, wallet, asset, facilitator, and trust policy from ArisPay. |
+| `apiUrl` | No | `https://api.arispay.app` | Override ArisPay API URL for staging/self-hosting. |
+| `facilitatorUrl` | No | Manifest value | Compatibility override. In v3, merchant capabilities are authoritative. |
+| `timeout` | No | `30000` | ArisPay/facilitator call timeout in ms. |
+| `cacheTtlMs` | No | `300000` | Merchant capability cache TTL. |
 
-```bash
-npm install payagent
-```
+### Compatibility mode
 
-```js
-import { createPayagentFetch } from 'payagent';
+Older code that passes `wallet` and `network` still works through a v2 shim, but new integrations should use `merchantId` and configure payout wallets in the dashboard. The shim will be removed in a future major version.
 
-const fetch = createPayagentFetch({
-  apiKey: 'ap_live_...',   // ArisPay API key
-  agentId: 'agent-123',    // Your agent ID
-});
+## Networks
 
-// This call will automatically handle any 402 challenges
-const res = await fetch('https://your-api.com/api/data');
-const data = await res.json();
-```
+PayGate currently settles USDC on EVM networks advertised by your merchant capability manifest. Base mainnet (`eip155:8453`) is the recommended production network.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paygate",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Accept payment from AI agents in two lines of code. Gate any Express or Fastify route with an x402 paywall backed by ArisPay — merchants don't hold keys, agents pay per-request, USDC settles in seconds on Base mainnet.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,6 +19,12 @@
       "types": "./dist/fastify.d.ts"
     }
   },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm build"
+  },
   "dependencies": {},
   "peerDependencies": {
     "express": ">=4.0.0",
@@ -67,10 +73,5 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/arispay-inc/ArisPay"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "type-check": "tsc --noEmit"
   }
-}
+}