@dexterai/x402 1.2.4 → 1.3.0

package/README.md

@@ -52,6 +52,21 @@ This SDK handles the entire flow automatically—you just call `fetch()` and pay
 npm install @dexterai/x402
 ```
 
+### Client (Node.js) — NEW!
+
+The simplest way to make x402 payments from scripts:
+
+```typescript
+import { wrapFetch } from '@dexterai/x402/client';
+
+const x402Fetch = wrapFetch(fetch, {
+  walletPrivateKey: process.env.SOLANA_PRIVATE_KEY,
+});
+
+// That's it. 402 responses are handled automatically.
+const response = await x402Fetch('https://api.example.com/protected');
+```
+
 ### Client (Browser)
 
 ```typescript
@@ -167,6 +182,40 @@ fromAtomicUnits(1500000n, 6);  // 1.5
 
 ## Server SDK
 
+### Express Middleware — NEW!
+
+One-liner payment protection for any Express endpoint:
+
+```typescript
+import express from 'express';
+import { x402Middleware } from '@dexterai/x402/server';
+
+const app = express();
+
+app.get('/api/protected',
+  x402Middleware({
+    payTo: 'YourSolanaAddress...',
+    amount: '0.01',  // $0.01 USD
+  }),
+  (req, res) => {
+    // This only runs after successful payment
+    res.json({ data: 'protected content' });
+  }
+);
+```
+
+Options:
+- `payTo` — Address to receive payments
+- `amount` — Price in USD (e.g., `'0.01'` for 1 cent)
+- `network` — CAIP-2 network (default: Solana mainnet)
+- `description` — Human-readable description
+- `facilitatorUrl` — Override facilitator (default: x402.dexter.cash)
+- `verbose` — Enable debug logging
+
+### Manual Server (Advanced)
+
+For more control over the payment flow:
+
 ```typescript
 import { createX402Server } from '@dexterai/x402/server';
 
@@ -197,8 +246,6 @@ app.post('/protected', async (req, res) => {
 });
 ```
 
-*Client SDK, React hook, and pricing utilities are production-verified at [dexter.cash/sdk](https://dexter.cash/sdk). `createX402Server` is a convenience wrapper not yet used in production.*
-
 ---
 
 ## Dynamic Pricing

package/dist/client/index.cjs

@@ -6,6 +6,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -412,6 +415,157 @@ var init_evm = __esm({
   }
 });
 
+// node_modules/base-x/src/cjs/index.cjs
+var require_cjs = __commonJS({
+  "node_modules/base-x/src/cjs/index.cjs"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function base(ALPHABET) {
+      if (ALPHABET.length >= 255) {
+        throw new TypeError("Alphabet too long");
+      }
+      const BASE_MAP = new Uint8Array(256);
+      for (let j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+      }
+      for (let i = 0; i < ALPHABET.length; i++) {
+        const x = ALPHABET.charAt(i);
+        const xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+          throw new TypeError(x + " is ambiguous");
+        }
+        BASE_MAP[xc] = i;
+      }
+      const BASE = ALPHABET.length;
+      const LEADER = ALPHABET.charAt(0);
+      const FACTOR = Math.log(BASE) / Math.log(256);
+      const iFACTOR = Math.log(256) / Math.log(BASE);
+      function encode(source) {
+        if (source instanceof Uint8Array) {
+        } else if (ArrayBuffer.isView(source)) {
+          source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        } else if (Array.isArray(source)) {
+          source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+          throw new TypeError("Expected Uint8Array");
+        }
+        if (source.length === 0) {
+          return "";
+        }
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+          pbegin++;
+          zeroes++;
+        }
+        const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+        const b58 = new Uint8Array(size);
+        while (pbegin !== pend) {
+          let carry = source[pbegin];
+          let i = 0;
+          for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+            carry += 256 * b58[it1] >>> 0;
+            b58[it1] = carry % BASE >>> 0;
+            carry = carry / BASE >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i;
+          pbegin++;
+        }
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+          it2++;
+        }
+        let str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+          str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+      }
+      function decodeUnsafe(source) {
+        if (typeof source !== "string") {
+          throw new TypeError("Expected String");
+        }
+        if (source.length === 0) {
+          return new Uint8Array();
+        }
+        let psz = 0;
+        let zeroes = 0;
+        let length = 0;
+        while (source[psz] === LEADER) {
+          zeroes++;
+          psz++;
+        }
+        const size = (source.length - psz) * FACTOR + 1 >>> 0;
+        const b256 = new Uint8Array(size);
+        while (psz < source.length) {
+          const charCode = source.charCodeAt(psz);
+          if (charCode > 255) {
+            return;
+          }
+          let carry = BASE_MAP[charCode];
+          if (carry === 255) {
+            return;
+          }
+          let i = 0;
+          for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+            carry += BASE * b256[it3] >>> 0;
+            b256[it3] = carry % 256 >>> 0;
+            carry = carry / 256 >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i;
+          psz++;
+        }
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+          it4++;
+        }
+        const vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size) {
+          vch[j++] = b256[it4++];
+        }
+        return vch;
+      }
+      function decode(string) {
+        const buffer = decodeUnsafe(string);
+        if (buffer) {
+          return buffer;
+        }
+        throw new Error("Non-base" + BASE + " character");
+      }
+      return {
+        encode,
+        decodeUnsafe,
+        decode
+      };
+    }
+    exports2.default = base;
+  }
+});
+
+// node_modules/bs58/src/cjs/index.cjs
+var require_cjs2 = __commonJS({
+  "node_modules/bs58/src/cjs/index.cjs"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var base_x_1 = __importDefault(require_cjs());
+    var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    exports2.default = (0, base_x_1.default)(ALPHABET);
+  }
+});
+
 // src/client/index.ts
 var client_exports = {};
 __export(client_exports, {
@@ -421,8 +575,11 @@ __export(client_exports, {
   USDC_MINT: () => USDC_MINT,
   X402Error: () => X402Error,
   createEvmAdapter: () => createEvmAdapter,
+  createKeypairWallet: () => createKeypairWallet,
   createSolanaAdapter: () => createSolanaAdapter,
-  createX402Client: () => createX402Client
+  createX402Client: () => createX402Client,
+  isKeypairWallet: () => isKeypairWallet,
+  wrapFetch: () => wrapFetch
 });
 module.exports = __toCommonJS(client_exports);
 
@@ -588,10 +745,33 @@ function createX402Client(config) {
     } else {
       payload = { transaction: signedTx.serialized };
     }
+    const originalUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let resolvedResource = requirements.resource;
+    if (typeof requirements.resource === "string") {
+      try {
+        const resolvedUrl = new URL(requirements.resource, originalUrl).toString();
+        if (resolvedUrl !== requirements.resource) {
+          log("Resolved relative resource URL:", requirements.resource, "\u2192", resolvedUrl);
+        }
+        resolvedResource = resolvedUrl;
+      } catch {
+        resolvedResource = requirements.resource;
+      }
+    } else if (requirements.resource && typeof requirements.resource === "object" && "url" in requirements.resource) {
+      const resourceObj = requirements.resource;
+      try {
+        const resolvedUrl = new URL(resourceObj.url, originalUrl).toString();
+        if (resolvedUrl !== resourceObj.url) {
+          log("Resolved relative resource URL:", resourceObj.url, "\u2192", resolvedUrl);
+          resolvedResource = { ...resourceObj, url: resolvedUrl };
+        }
+      } catch {
+      }
+    }
     const paymentSignature = {
       x402Version: accept.x402Version ?? 2,
       // Echo version from 402 response, default to 2
-      resource: requirements.resource,
+      resource: resolvedResource,
       accepted: accept,
       payload
     };
@@ -626,6 +806,98 @@ function createX402Client(config) {
     fetch: x402Fetch
   };
 }
+
+// src/client/keypair-wallet.ts
+var import_web32 = require("@solana/web3.js");
+function createKeypairWallet(privateKey) {
+  let keypair;
+  if (typeof privateKey === "string") {
+    const bs58 = require_cjs2();
+    const decode = bs58.decode || bs58.default?.decode;
+    if (!decode) {
+      throw new Error("bs58 module not found or incompatible version");
+    }
+    try {
+      const decoded = decode(privateKey);
+      keypair = import_web32.Keypair.fromSecretKey(decoded);
+    } catch (e) {
+      try {
+        const parsed = JSON.parse(privateKey);
+        if (Array.isArray(parsed)) {
+          keypair = import_web32.Keypair.fromSecretKey(Uint8Array.from(parsed));
+        } else {
+          throw new Error("Invalid private key format");
+        }
+      } catch {
+        throw new Error(
+          "Invalid private key. Expected base58 string or JSON array of bytes."
+        );
+      }
+    }
+  } else if (Array.isArray(privateKey)) {
+    keypair = import_web32.Keypair.fromSecretKey(Uint8Array.from(privateKey));
+  } else if (privateKey instanceof Uint8Array) {
+    keypair = import_web32.Keypair.fromSecretKey(privateKey);
+  } else {
+    throw new Error(
+      "Invalid private key type. Expected string, number[], or Uint8Array."
+    );
+  }
+  return {
+    publicKey: {
+      toBase58: () => keypair.publicKey.toBase58()
+    },
+    signTransaction: async (tx) => {
+      if (tx instanceof import_web32.VersionedTransaction) {
+        tx.sign([keypair]);
+        return tx;
+      } else if (tx instanceof import_web32.Transaction) {
+        tx.sign(keypair);
+        return tx;
+      }
+      throw new Error("Unknown transaction type");
+    },
+    keypair
+  };
+}
+function isKeypairWallet(wallet) {
+  if (!wallet || typeof wallet !== "object") return false;
+  const w = wallet;
+  return "keypair" in w && w.keypair instanceof import_web32.Keypair && "publicKey" in w && "signTransaction" in w;
+}
+
+// src/client/wrap-fetch.ts
+function wrapFetch(fetchImpl, options) {
+  const {
+    walletPrivateKey,
+    evmPrivateKey,
+    preferredNetwork,
+    // facilitatorUrl is reserved for future use when we add facilitator selection
+    rpcUrls,
+    maxAmountAtomic,
+    verbose
+  } = options;
+  if (!walletPrivateKey && !evmPrivateKey) {
+    throw new Error("At least one wallet private key is required (walletPrivateKey or evmPrivateKey)");
+  }
+  const wallets = {};
+  if (walletPrivateKey) {
+    wallets.solana = createKeypairWallet(walletPrivateKey);
+  }
+  if (evmPrivateKey) {
+    console.warn("[x402] EVM private key support in wrapFetch is not yet implemented. Use createX402Client with a viem wallet instead.");
+  }
+  const clientConfig = {
+    wallets,
+    preferredNetwork,
+    rpcUrls,
+    maxAmountAtomic,
+    fetch: fetchImpl,
+    verbose
+  };
+  const client = createX402Client(clientConfig);
+  return client.fetch.bind(client);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BASE_MAINNET,
@@ -634,7 +906,10 @@ function createX402Client(config) {
   USDC_MINT,
   X402Error,
   createEvmAdapter,
+  createKeypairWallet,
   createSolanaAdapter,
-  createX402Client
+  createX402Client,
+  isKeypairWallet,
+  wrapFetch
 });
 //# sourceMappingURL=index.cjs.map