moltspay 1.5.0 → 2.0.0

package/dist/cli/index.mjs

@@ -21,18 +21,21 @@ var init_esm_shims = __esm({
 init_esm_shims();
 import { webcrypto } from "crypto";
 import { Command } from "commander";
-import { homedir as homedir3 } from "os";
-import { join as join5, dirname, resolve } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join6, dirname as dirname2, resolve as resolve2 } from "path";
 import { existsSync as existsSync5, writeFileSync as writeFileSync3, readFileSync as readFileSync5, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
-import { spawn } from "child_process";
-import { ethers as ethers2 } from "ethers";
+import { spawn as spawn2 } from "child_process";
+import { ethers as ethers4 } from "ethers";
 
 // src/client/index.ts
 init_esm_shims();
+
+// src/client/node/index.ts
+init_esm_shims();
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, statSync, chmodSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { Wallet, ethers } from "ethers";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { Wallet as Wallet2, ethers as ethers2 } from "ethers";
 
 // src/chains/index.ts
 init_esm_shims();
@@ -208,6 +211,10 @@ function getChain(name) {
   }
   return config;
 }
+var ALIPAY_CHAIN_ID = "alipay";
+function isAlipayChainId(id) {
+  return id === ALIPAY_CHAIN_ID;
+}
 
 // src/wallet/solana.ts
 init_esm_shims();
@@ -526,16 +533,16 @@ var SolanaFacilitator = class extends BaseFacilitator {
     return this.supportedNetworks.includes(network);
   }
 };
-async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey) {
+async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey, connection) {
   const chainConfig = SOLANA_CHAINS[chain];
-  const connection = new Connection3(chainConfig.rpc, "confirmed");
+  const conn = connection ?? new Connection3(chainConfig.rpc, "confirmed");
   const mint = new PublicKey3(chainConfig.tokens.USDC.mint);
   const actualFeePayer = feePayerPubkey || senderPubkey;
   const senderATA = await getAssociatedTokenAddress2(mint, senderPubkey);
   const recipientATA = await getAssociatedTokenAddress2(mint, recipientPubkey);
   const transaction = new Transaction();
   try {
-    await getAccount2(connection, recipientATA);
+    await getAccount2(conn, recipientATA);
   } catch {
     transaction.add(
       createAssociatedTokenAccountInstruction(
@@ -566,22 +573,944 @@ async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amo
       // decimals
     )
   );
-  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash();
   transaction.recentBlockhash = blockhash;
   transaction.feePayer = actualFeePayer;
   return transaction;
 }
 
-// src/client/index.ts
+// src/client/node/index.ts
 import { PublicKey as PublicKey4 } from "@solana/web3.js";
 
-// src/client/types.ts
+// src/client/core/index.ts
 init_esm_shims();
 
-// src/client/index.ts
+// src/client/core/types.ts
+init_esm_shims();
 var X402_VERSION = 2;
 var PAYMENT_REQUIRED_HEADER = "x-payment-required";
 var PAYMENT_HEADER = "x-payment";
+
+// src/client/core/chain-map.ts
+init_esm_shims();
+var NETWORK_TO_CHAIN = {
+  "eip155:8453": "base",
+  "eip155:137": "polygon",
+  "eip155:84532": "base_sepolia",
+  "eip155:42431": "tempo_moderato",
+  "eip155:56": "bnb",
+  "eip155:97": "bnb_testnet",
+  "solana:mainnet": "solana",
+  "solana:devnet": "solana_devnet"
+};
+var CHAIN_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_TO_CHAIN).map(([network, chain]) => [chain, network])
+);
+function networkToChainName(network) {
+  return NETWORK_TO_CHAIN[network] ?? null;
+}
+
+// src/client/core/base64.ts
+init_esm_shims();
+var BufferCtor = globalThis.Buffer;
+
+// src/client/core/errors.ts
+init_esm_shims();
+var MoltsPayError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "MoltsPayError";
+    this.code = code;
+  }
+};
+
+// src/client/core/eip3009.ts
+init_esm_shims();
+var EIP3009_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" }
+  ]
+};
+function buildEIP3009TypedData(args) {
+  const validAfter = args.validAfter ?? "0";
+  const validBefore = args.validBefore ?? (Math.floor(Date.now() / 1e3) + 3600).toString();
+  const authorization = {
+    from: args.from,
+    to: args.to,
+    value: args.value,
+    validAfter,
+    validBefore,
+    nonce: args.nonce
+  };
+  return {
+    domain: {
+      name: args.tokenName,
+      version: args.tokenVersion,
+      chainId: args.chainId,
+      verifyingContract: args.tokenAddress
+    },
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: authorization
+  };
+}
+
+// src/client/core/eip2612.ts
+init_esm_shims();
+
+// src/client/core/bnb-intent.ts
+init_esm_shims();
+var BNB_INTENT_TYPES = {
+  PaymentIntent: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "token", type: "address" },
+    { name: "service", type: "string" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var BNB_DOMAIN_NAME = "MoltsPay";
+var BNB_DOMAIN_VERSION = "1";
+function buildBnbIntentTypedData(args) {
+  const intent = {
+    from: args.from,
+    to: args.to,
+    amount: args.amount,
+    token: args.tokenAddress,
+    service: args.service,
+    nonce: args.nonce,
+    deadline: args.deadline
+  };
+  return {
+    domain: {
+      name: BNB_DOMAIN_NAME,
+      version: BNB_DOMAIN_VERSION,
+      chainId: args.chainId
+    },
+    types: BNB_INTENT_TYPES,
+    primaryType: "PaymentIntent",
+    message: intent
+  };
+}
+
+// src/client/core/solana-tx.ts
+init_esm_shims();
+
+// src/client/core/x402.ts
+init_esm_shims();
+
+// src/client/node/signer.ts
+init_esm_shims();
+import { ethers } from "ethers";
+import { Transaction as Transaction2 } from "@solana/web3.js";
+var NodeSigner = class {
+  evmWallet;
+  getSolanaKeypair;
+  constructor(evmWallet, options = {}) {
+    this.evmWallet = evmWallet;
+    this.getSolanaKeypair = options.getSolanaKeypair ?? (() => null);
+  }
+  async getEvmAddress() {
+    return this.evmWallet.address;
+  }
+  async getSolanaAddress() {
+    const kp = this.getSolanaKeypair();
+    return kp ? kp.publicKey.toBase58() : null;
+  }
+  async signTypedData(envelope) {
+    const mutableTypes = {};
+    for (const [key, fields] of Object.entries(envelope.types)) {
+      mutableTypes[key] = [...fields];
+    }
+    return this.evmWallet.signTypedData(
+      envelope.domain,
+      mutableTypes,
+      envelope.message
+    );
+  }
+  async sendEvmTransaction(args) {
+    const chain = findChainByChainId(args.chainId);
+    if (!chain) {
+      throw new Error(`sendEvmTransaction: unknown chainId ${args.chainId}`);
+    }
+    const provider = new ethers.JsonRpcProvider(chain.rpc);
+    const connected = this.evmWallet.connect(provider);
+    const tx = await connected.sendTransaction({
+      to: args.to,
+      data: args.data,
+      value: args.value ? BigInt(args.value) : 0n
+    });
+    return tx.hash;
+  }
+  async signSolanaTransaction(args) {
+    const kp = this.getSolanaKeypair();
+    if (!kp) {
+      throw new Error("signSolanaTransaction: no Solana wallet configured");
+    }
+    const tx = Transaction2.from(Buffer.from(args.transactionBase64, "base64"));
+    if (args.partialSign) {
+      tx.partialSign(kp);
+    } else {
+      tx.sign(kp);
+    }
+    return tx.serialize({ requireAllSignatures: false }).toString("base64");
+  }
+};
+function findChainByChainId(chainId) {
+  for (const cfg of Object.values(CHAINS)) {
+    if (cfg.chainId === chainId) {
+      return cfg;
+    }
+  }
+  return void 0;
+}
+
+// src/client/alipay/index.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+import { mkdir, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/client/alipay/cli.ts
+init_esm_shims();
+import { spawn } from "child_process";
+
+// src/client/alipay/log.ts
+init_esm_shims();
+var RANK = { off: 0, info: 1, debug: 2 };
+function normalizeLevel(v) {
+  const s = (v ?? "").toLowerCase();
+  return s === "info" || s === "debug" ? s : "off";
+}
+var level = normalizeLevel(process.env.MOLTSPAY_ALIPAY_LOG);
+var sink = (line) => {
+  process.stderr.write(line + "\n");
+};
+function enabledFor(want) {
+  return RANK[level] >= RANK[want];
+}
+function render(event, fields) {
+  const parts = ["[moltspay:alipay]", String(fields.ts), event];
+  if (fields.flow) parts.push(`flow=${fields.flow}`);
+  if (fields.step) parts.push(`step=${fields.step}`);
+  if (typeof fields.ms === "number") parts.push(`${fields.ms}ms`);
+  for (const [k, v] of Object.entries(fields)) {
+    if (["ts", "level", "event", "flow", "step", "ms"].includes(k)) continue;
+    parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+  }
+  return parts.join(" ");
+}
+function emit(lvl, event, fields) {
+  if (!enabledFor(lvl)) return;
+  const full = { ts: (/* @__PURE__ */ new Date()).toISOString(), level: lvl, event, ...fields };
+  try {
+    sink(render(event, full), full);
+  } catch {
+  }
+}
+var alipayLog = {
+  info: (event, fields = {}) => emit("info", event, fields),
+  debug: (event, fields = {}) => emit("debug", event, fields),
+  /** True if anything at all would be logged (cheap guard for hot paths). */
+  enabled: () => level !== "off"
+};
+async function timeStep(step, flow, fn) {
+  if (!alipayLog.enabled()) return fn();
+  const t0 = Date.now();
+  alipayLog.debug("step.start", { flow, step });
+  try {
+    const out = await fn();
+    alipayLog.info("step.end", { flow, step, ms: Date.now() - t0, ok: true });
+    return out;
+  } catch (err) {
+    alipayLog.info("step.end", {
+      flow,
+      step,
+      ms: Date.now() - t0,
+      ok: false,
+      err: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  }
+}
+
+// src/client/alipay/cli.ts
+var ALLOWED_ENV = /* @__PURE__ */ new Set([
+  "AIPAY_OUTPUT_CHANNEL",
+  "AIPAY_SESSION_ID",
+  "AIPAY_FRAMEWORK",
+  "AIPAY_MODEL",
+  "AIPAY_OS",
+  // Minimal survival set for spawn to find the binary and a home dir.
+  "PATH",
+  "HOME"
+]);
+function filterEnv(env) {
+  return Object.fromEntries(
+    Object.entries(env).filter(([k]) => ALLOWED_ENV.has(k))
+  );
+}
+function makeLineSplitter(onLine) {
+  let buf = "";
+  return (chunk) => {
+    buf += chunk.toString("utf-8");
+    let nl;
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      onLine(buf.slice(0, nl));
+      buf = buf.slice(nl + 1);
+    }
+  };
+}
+function profileEnv(step, flow) {
+  const want = process.env.MOLTSPAY_ALIPAY_CLI_PROFILE;
+  const hook = process.env.MOLTSPAY_ALIPAY_CLI_PROFILE_HOOK;
+  if (!want || !hook) return {};
+  const steps = want.split(",").map((s) => s.trim());
+  if (!steps.includes("all") && !steps.includes(step)) return {};
+  const dir = process.env.MOLTSPAY_ALIPAY_CLI_PROFILE_DIR || "/tmp";
+  const safe = `${flow ?? "noflow"}-${step}-${Date.now()}`.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const out = `${dir}/cli-profile-${safe}.json`;
+  alipayLog.info("cli.profile", { flow, step, out });
+  return {
+    NODE_OPTIONS: `--require=${hook}`,
+    MOLTSPAY_CLI_PROFILE_OUT: out
+  };
+}
+var runCli = (args, opts = {}) => {
+  const bin = opts.bin ?? "alipay-bot";
+  const step = opts.step ?? args[0] ?? "(no-arg)";
+  const startedAt = Date.now();
+  const lines = [];
+  const collect = (line) => {
+    lines.push(line);
+    alipayLog.debug("cli.line", {
+      flow: opts.flow,
+      step,
+      ms: Date.now() - startedAt,
+      preview: line.slice(0, 120)
+    });
+    opts.onLine?.(line);
+  };
+  alipayLog.debug("step.start", { flow: opts.flow, step });
+  return new Promise((resolve3, reject) => {
+    const child = spawn(bin, args, {
+      env: { ...filterEnv(process.env), ...profileEnv(step, opts.flow), ...opts.env ?? {} }
+    });
+    if (opts.signal) {
+      if (opts.signal.aborted) child.kill("SIGTERM");
+      opts.signal.addEventListener("abort", () => child.kill("SIGTERM"), { once: true });
+    }
+    let sawByte = false;
+    const onChunk = (stream) => (chunk) => {
+      const ms = Date.now() - startedAt;
+      if (!sawByte) {
+        sawByte = true;
+        alipayLog.debug("cli.firstbyte", { flow: opts.flow, step, ms });
+      }
+      alipayLog.debug("cli.chunk", { flow: opts.flow, step, ms, stream, bytes: chunk.length });
+    };
+    const onStdout = makeLineSplitter(collect);
+    const onStderr = makeLineSplitter(collect);
+    child.stdout?.on("data", onChunk("out"));
+    child.stderr?.on("data", onChunk("err"));
+    child.stdout?.on("data", onStdout);
+    child.stderr?.on("data", onStderr);
+    child.on("error", (err) => {
+      alipayLog.info("cli.exit", {
+        flow: opts.flow,
+        step,
+        ms: Date.now() - startedAt,
+        ok: false,
+        err: err.message
+      });
+      reject(err);
+    });
+    child.on("close", (code) => {
+      alipayLog.info("cli.exit", {
+        flow: opts.flow,
+        step,
+        ms: Date.now() - startedAt,
+        ok: (code ?? 1) === 0,
+        code: code ?? 1
+      });
+      resolve3({ exitCode: code ?? 1, lines });
+    });
+  });
+};
+
+// src/client/alipay/install.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/client/alipay/errors.ts
+init_esm_shims();
+var AlipayCliNotFoundError = class extends MoltsPayError {
+  constructor(message) {
+    super("ALIPAY_CLI_NOT_FOUND", message);
+    this.name = "AlipayCliNotFoundError";
+  }
+};
+var AlipayCliVersionError = class extends MoltsPayError {
+  constructor(message) {
+    super("ALIPAY_CLI_VERSION", message);
+    this.name = "AlipayCliVersionError";
+  }
+};
+var NeedsWalletSetupError = class extends MoltsPayError {
+  constructor(message = "Alipay wallet not set up. Run: moltspay alipay apply") {
+    super("ALIPAY_NEEDS_WALLET_SETUP", message);
+    this.name = "NeedsWalletSetupError";
+  }
+};
+var AlipayPaymentRejectedError = class extends MoltsPayError {
+  constructor(message) {
+    super("ALIPAY_PAYMENT_REJECTED", message);
+    this.name = "AlipayPaymentRejectedError";
+  }
+};
+var AlipayPaymentTimeoutError = class extends MoltsPayError {
+  constructor(message) {
+    super("ALIPAY_PAYMENT_TIMEOUT", message);
+    this.name = "AlipayPaymentTimeoutError";
+  }
+};
+var AlipayProtocolError = class extends MoltsPayError {
+  constructor(message) {
+    super("ALIPAY_PROTOCOL", message);
+    this.name = "AlipayProtocolError";
+  }
+};
+var UnsupportedRailError = class extends MoltsPayError {
+  constructor(rail, message) {
+    super("UNSUPPORTED_RAIL", message ?? `Rail not supported by server: ${rail}`);
+    this.rail = rail;
+    this.name = "UnsupportedRailError";
+  }
+};
+
+// src/client/alipay/install.ts
+var execFileAsync = promisify(execFile);
+var MIN_CLI_VERSION = "0.3.15";
+function semverLt(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10));
+  const pb = b.split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
+function parseVersion(stdout) {
+  return stdout.match(/v?(\d+\.\d+\.\d+)/)?.[1] ?? null;
+}
+var defaultGetVersion = async () => {
+  const { stdout } = await execFileAsync("alipay-bot", ["--version"]);
+  return stdout;
+};
+async function ensureCliUncached(getVersion2) {
+  let stdout;
+  try {
+    stdout = await getVersion2();
+  } catch (e) {
+    if (e?.code === "ENOENT") {
+      throw new AlipayCliNotFoundError(
+        "alipay-bot not installed. Run: npx -y @alipay/agent-payment install-cli"
+      );
+    }
+    throw e;
+  }
+  const version = parseVersion(stdout);
+  if (!version || semverLt(version, MIN_CLI_VERSION)) {
+    throw new AlipayCliVersionError(
+      `alipay-bot ${version ?? "?"} found, need \u2265 ${MIN_CLI_VERSION}. Run: npx -y @alipay/agent-payment@latest update`
+    );
+  }
+  return version;
+}
+var cachedVersion = null;
+var inflight = null;
+async function ensureCli(getVersion2 = defaultGetVersion) {
+  if (getVersion2 !== defaultGetVersion) {
+    return ensureCliUncached(getVersion2);
+  }
+  if (cachedVersion) return cachedVersion;
+  if (!inflight) {
+    inflight = ensureCliUncached(getVersion2).then((v) => {
+      cachedVersion = v;
+      return v;
+    }).finally(() => {
+      inflight = null;
+    });
+  }
+  return inflight;
+}
+
+// src/client/alipay/poll.ts
+init_esm_shims();
+var POLL_INTERVAL_MS = 3e3;
+var POLL_MAX_INFLIGHT = 2;
+function resolveMaxInflight(override) {
+  if (override !== void 0) return Math.max(1, Math.floor(override));
+  const raw = process.env.MOLTSPAY_ALIPAY_POLL_MAX_INFLIGHT;
+  if (raw !== void 0 && raw.trim() !== "") {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  }
+  return POLL_MAX_INFLIGHT;
+}
+function resolveLaunchGap(override) {
+  if (override !== void 0) return Math.max(0, override);
+  const raw = process.env.MOLTSPAY_ALIPAY_POLL_LAUNCH_MS;
+  if (raw !== void 0 && raw.trim() !== "") {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return POLL_INTERVAL_MS;
+}
+function parseStatus(lines) {
+  const raw = lines.join("\n").trim();
+  try {
+    const json = JSON.parse(raw);
+    if (json && typeof json === "object") {
+      if (typeof json.success === "boolean") {
+        if (json.success) return "paid";
+        const err = String(json.errorCode ?? "").toUpperCase();
+        if (/UNPAID|WAIT|PENDING|PROCESS|NOTPAY/.test(err)) return "pending";
+        if (/CLOSED|CANCEL|FAIL|REJECT|REFUSE|TIMEOUT|EXPIRE/.test(err)) return "rejected";
+        return "pending";
+      }
+      if (typeof json.code !== "undefined") {
+        if (Number(json.code) === 200) return "paid";
+        const msg = `${json.message ?? ""}${json.reason ?? ""}`;
+        if (/关闭|失败|拒绝|取消|超时|已撤销/.test(msg)) return "rejected";
+        return "pending";
+      }
+      if (typeof json.body === "string") {
+        return classifyReportText(json.body);
+      }
+    }
+  } catch {
+  }
+  return classifyReportText(raw);
+}
+function classifyReportText(s) {
+  const text = s.toUpperCase();
+  if (/查询支付状态成功并获取资源/.test(s) || /资源响应状态[^0-9\n]{0,8}200/.test(s) || /TRADE_SUCCESS|TRADE_FINISHED|"STATUS":\s*"FULFILLED"/.test(text)) return "paid";
+  if (/TRADE_CLOSED|REJECTED|REFUSE|CANCEL/.test(text) || /交易关闭|支付失败|已拒绝|已取消|已撤销|交易超时/.test(s)) return "rejected";
+  if (/WAIT_BUYER_PAY|UNPAID|PENDING|WAITING/.test(text) || /交易未支付|等待付款|待支付|未支付/.test(s)) return "pending";
+  return "unknown";
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal?.aborted) return reject(new Error("aborted"));
+    const t = setTimeout(resolve3, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        reject(new Error("aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+var LAUNCH = /* @__PURE__ */ Symbol("launch");
+async function pollUntil(tradeNo, resourceUrl, opts) {
+  const runner = opts.runner ?? runCli;
+  const sleep = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? Date.now;
+  const maxInflight = resolveMaxInflight(opts.maxInflight);
+  const launchGap = resolveLaunchGap(opts.launchIntervalMs);
+  const args = [
+    "402-query-payment-status",
+    "-t",
+    tradeNo,
+    "-r",
+    resourceUrl,
+    ...opts.method ? ["-m", opts.method] : [],
+    ...opts.data ? ["-d", opts.data] : []
+  ];
+  const internal = new AbortController();
+  const signal = opts.signal ? AbortSignal.any([opts.signal, internal.signal]) : internal.signal;
+  let tick = 0;
+  let lastLaunch = -Infinity;
+  const inflight2 = /* @__PURE__ */ new Set();
+  const launch = () => {
+    tick += 1;
+    const myTick = tick;
+    lastLaunch = now();
+    const run = (async () => {
+      const { lines } = await runner(args, {
+        signal,
+        step: "query-payment-status",
+        flow: tradeNo
+      });
+      const status = parseStatus(lines);
+      alipayLog.debug("poll.tick", { flow: tradeNo, tick: myTick, status });
+      return { status, lines };
+    })();
+    const tracked = run.finally(() => {
+      inflight2.delete(tracked);
+    });
+    inflight2.add(tracked);
+  };
+  try {
+    for (; ; ) {
+      if (opts.signal?.aborted) throw new Error("aborted");
+      const expired = now() >= opts.deadline;
+      if (expired && inflight2.size === 0) {
+        throw new AlipayPaymentTimeoutError(
+          `Payment ${tradeNo} not completed before pay_before deadline`
+        );
+      }
+      while (!expired && inflight2.size < maxInflight && now() - lastLaunch >= launchGap) {
+        launch();
+      }
+      const waiters = [...inflight2];
+      if (!expired && inflight2.size < maxInflight) {
+        const untilNext = Math.max(0, launchGap - (now() - lastLaunch));
+        waiters.push(sleep(untilNext, signal).then(() => LAUNCH, () => LAUNCH));
+      }
+      const winner = await Promise.race(waiters);
+      if (winner === LAUNCH) continue;
+      if (winner.status === "paid") return { status: "paid", lines: winner.lines };
+      if (winner.status === "rejected") {
+        throw new AlipayPaymentRejectedError(`Payment ${tradeNo} was rejected`);
+      }
+    }
+  } finally {
+    internal.abort();
+    for (const p of inflight2) p.catch(() => void 0);
+  }
+}
+
+// src/client/alipay/index.ts
+var TRADE_NO_RE = /^\d{32}$/;
+function resolveSessionId(explicit, envSession) {
+  return explicit ?? envSession ?? randomUUID();
+}
+function assertTradeNo(t) {
+  if (!TRADE_NO_RE.test(t)) {
+    throw new AlipayProtocolError(`invalid tradeNo (expect 32 digits): ${t}`);
+  }
+}
+function parseTradeNo(lines) {
+  for (const line of lines) {
+    const labeled = line.match(/trade[_-]?no["'\s:=]+(\d{32})/i);
+    if (labeled) return labeled[1];
+    const bare = line.match(/\b(\d{32})\b/);
+    if (bare) return bare[1];
+  }
+  return null;
+}
+function parsePaymentUrl(lines) {
+  let paymentUrl;
+  let shortenUrl;
+  for (const line of lines) {
+    const m = line.match(/(alipays?:\/\/\S+|https?:\/\/\S+)/i);
+    if (!m) continue;
+    const url = m[1].replace(/[)\]`>]+$/, "");
+    if (/short|qr\.alipay|surl|\/s\//i.test(line) && !shortenUrl) shortenUrl = url;
+    else if (!paymentUrl) paymentUrl = url;
+  }
+  if (!paymentUrl && shortenUrl) paymentUrl = shortenUrl;
+  return { paymentUrl, shortenUrl };
+}
+function extractMedia(line) {
+  const m = line.match(/^\s*MEDIA:\s*(.+?)\s*$/);
+  return m ? m[1] : null;
+}
+function isWalletReady(lines) {
+  const text = lines.join("\n").trim();
+  try {
+    const json = JSON.parse(text);
+    if (json && typeof json.code !== "undefined") return Number(json.code) === 200;
+  } catch {
+  }
+  return !/未开通|未开启|NOT[_\s-]*(OPEN|BOUND|SET)|NEEDS?[_\s-]*SETUP|NO[_\s-]*WALLET/i.test(text);
+}
+function extractResourceFromReport(report) {
+  const label = report.search(/资源响应体/);
+  const start = report.indexOf("{", label === -1 ? 0 : label);
+  if (start === -1) return void 0;
+  let depth = 0, inStr = false, esc = false;
+  for (let i = start; i < report.length; i++) {
+    const ch = report[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) {
+      const slice = report.slice(start, i + 1);
+      try {
+        const obj = JSON.parse(slice);
+        const r = obj?.resourceResponse ?? obj?.result ?? obj?.data ?? obj?.body ?? obj;
+        return typeof r === "string" ? r : JSON.stringify(r);
+      } catch {
+        return slice;
+      }
+    }
+  }
+  return void 0;
+}
+function extractBody(lines) {
+  const text = lines.join("\n").trim();
+  try {
+    const json = JSON.parse(text);
+    if (json && typeof json === "object") {
+      if (json.resourceResponse !== void 0 && json.resourceResponse !== null) {
+        const rr = json.resourceResponse;
+        const r = typeof rr === "object" ? rr.result ?? rr.data ?? rr.body ?? rr : rr;
+        return typeof r === "string" ? r : JSON.stringify(r);
+      }
+      if (typeof json.body === "string") {
+        const inner = extractResourceFromReport(json.body);
+        return inner ?? json.body;
+      }
+      const body = json.data ?? json.result ?? json.body ?? json.resource;
+      if (body !== void 0) return typeof body === "string" ? body : JSON.stringify(body);
+      return text;
+    }
+  } catch {
+  }
+  const idx = lines.findIndex((l) => /^\s*BODY:/.test(l));
+  if (idx !== -1) {
+    const first = lines[idx].replace(/^\s*BODY:\s*/, "");
+    return [first, ...lines.slice(idx + 1)].join("\n").trim();
+  }
+  return lines.filter((l) => !/^\s*(MEDIA|STATUS|INFO):/.test(l)).join("\n").trim();
+}
+var DEFAULT_WALLET_TTL_MS = 10 * 60 * 1e3;
+function resolveWalletTtlMs() {
+  const raw = process.env.MOLTSPAY_ALIPAY_WALLET_TTL_MS;
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_WALLET_TTL_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_WALLET_TTL_MS;
+}
+var walletReadyUntil = /* @__PURE__ */ new Map();
+var DEFAULT_INTENT_TTL_MS = 10 * 60 * 1e3;
+function resolveIntentTtlMs() {
+  const raw = process.env.MOLTSPAY_ALIPAY_INTENT_TTL_MS;
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_INTENT_TTL_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_INTENT_TTL_MS;
+}
+var intentDoneUntil = /* @__PURE__ */ new Map();
+var AlipayClient = class {
+  sessionId;
+  configDir;
+  framework;
+  runner;
+  getVersion;
+  now;
+  /** Only the default runner may use the process-level wallet cache. */
+  walletCacheable;
+  /** Only the default runner may use the process-level payment-intent cache. */
+  intentCacheable;
+  constructor(opts = {}) {
+    this.sessionId = resolveSessionId(opts.sessionId, process.env.AIPAY_SESSION_ID);
+    this.configDir = opts.configDir ?? join2(homedir2(), ".moltspay");
+    this.framework = opts.framework ?? process.env.AIPAY_FRAMEWORK ?? "openclaw";
+    this.runner = opts.runner ?? runCli;
+    this.getVersion = opts.getVersion;
+    this.now = opts.now ?? Date.now;
+    this.walletCacheable = opts.cacheWallet ?? !opts.runner;
+    this.intentCacheable = opts.cacheIntent ?? !opts.runner;
+  }
+  /**
+   * Throws NeedsWalletSetupError unless alipay-bot reports an opened wallet.
+   *
+   * Skips the ~22s `check-wallet` spawn entirely when a prior call cached a
+   * "ready" verdict within the TTL (see {@link DEFAULT_WALLET_TTL_MS}).
+   */
+  async checkWallet(signal, flow) {
+    const ttlMs = resolveWalletTtlMs();
+    const cacheKey = `${this.configDir}::${this.framework}`;
+    const useCache = this.walletCacheable && ttlMs > 0;
+    if (useCache) {
+      const until = walletReadyUntil.get(cacheKey);
+      if (until !== void 0 && this.now() < until) {
+        alipayLog.info("wallet.cache", { flow, step: "check-wallet", hit: true, ttlMsLeft: until - this.now() });
+        return;
+      }
+    }
+    const { lines } = await this.runner(["check-wallet"], { signal, step: "check-wallet", flow });
+    if (!isWalletReady(lines)) {
+      if (this.walletCacheable) walletReadyUntil.delete(cacheKey);
+      throw new NeedsWalletSetupError(
+        "Alipay wallet not opened. Run: moltspay alipay apply (then: moltspay alipay bind)"
+      );
+    }
+    if (useCache) {
+      walletReadyUntil.set(cacheKey, this.now() + ttlMs);
+      alipayLog.info("wallet.cache", { flow, step: "check-wallet", hit: false, cachedForMs: ttlMs });
+    }
+  }
+  /** Run the full 8-step flow and resolve with the resource body. */
+  async pay402(opts) {
+    const { resourceUrl, requirement, signal } = opts;
+    const extra = requirement.extra ?? {};
+    const paymentNeededHeader = String(extra.payment_needed_header ?? "");
+    if (!paymentNeededHeader) {
+      throw new AlipayProtocolError("alipay requirement missing extra.payment_needed_header");
+    }
+    const flow = this.sessionId;
+    const flowStart = this.now();
+    alipayLog.info("flow.start", { flow, resource: resourceUrl });
+    const media = [];
+    const onLine = (line) => {
+      const m = extractMedia(line);
+      if (m) media.push(m);
+      else opts.onLine?.(line);
+    };
+    const intentSummary = opts.intentSummary?.trim() || `\u652F\u4ED8 ${requirement.amount ?? ""} ${requirement.asset ?? "CNY"}`.trim();
+    await timeStep("ensure-cli", flow, () => ensureCli(this.getVersion));
+    const intentTtlMs = resolveIntentTtlMs();
+    const intentKey = `${this.configDir}::${this.framework}`;
+    const useIntentCache = this.intentCacheable && intentTtlMs > 0;
+    const intentUntil = useIntentCache ? intentDoneUntil.get(intentKey) : void 0;
+    if (intentUntil !== void 0 && this.now() < intentUntil) {
+      alipayLog.info("intent.cache", { flow, step: "payment-intent", hit: true, ttlMsLeft: intentUntil - this.now() });
+    } else {
+      await this.runner(
+        [
+          "payment-intent",
+          "--session-id",
+          this.sessionId,
+          "--intent-summary",
+          intentSummary,
+          "--framework",
+          this.framework
+        ],
+        { onLine, signal, step: "payment-intent", flow }
+      );
+      if (useIntentCache) {
+        intentDoneUntil.set(intentKey, this.now() + intentTtlMs);
+        alipayLog.info("intent.cache", { flow, step: "payment-intent", hit: false, cachedForMs: intentTtlMs });
+      }
+    }
+    await this.checkWallet(signal, flow);
+    const reqId = String(extra.out_trade_no ?? randomUUID());
+    const dir = join2(this.configDir, "alipay");
+    await mkdir(dir, { recursive: true });
+    const challengeFile = join2(dir, `402_${reqId}.txt`);
+    await writeFile(challengeFile, paymentNeededHeader, "utf-8");
+    const payArgs = [
+      "402-buyer-pay",
+      "-f",
+      challengeFile,
+      "-r",
+      resourceUrl,
+      "-s",
+      this.sessionId,
+      "-i",
+      intentSummary,
+      "-w",
+      this.framework
+    ];
+    if (opts.method) payArgs.push("-m", opts.method);
+    if (opts.data) payArgs.push("-d", opts.data);
+    const payRun = await this.runner(payArgs, { onLine, signal, step: "402-buyer-pay", flow });
+    const tradeNo = parseTradeNo(payRun.lines);
+    if (!tradeNo) {
+      throw new AlipayProtocolError("402-buyer-pay did not return a tradeNo");
+    }
+    assertTradeNo(tradeNo);
+    const { paymentUrl, shortenUrl } = parsePaymentUrl(payRun.lines);
+    if (paymentUrl) {
+      alipayLog.info("flow.pending", { flow, tradeNo, ms: this.now() - flowStart });
+      opts.onPaymentPending?.({ paymentUrl, shortenUrl, tradeNo });
+    }
+    const pendingAt = this.now();
+    const windowMs = (requirement.maxTimeoutSeconds ?? 30 * 60) * 1e3;
+    const deadline = this.now() + (opts.timeoutMs ?? windowMs);
+    const poll = await pollUntil(tradeNo, resourceUrl, {
+      // No onLine: the status-poll output embeds the resource and must not reach
+      // the log stream — the body is surfaced via the return value below (§9.3).
+      deadline,
+      signal,
+      runner: this.runner,
+      now: this.now,
+      // Re-fetch the resource the same way it was paid (POST + body), else the
+      // status poll defaults to GET and 404s on a POST-only `/execute`.
+      method: opts.method,
+      data: opts.data
+    });
+    alipayLog.info("flow.settled", { flow, tradeNo, ms: this.now() - pendingAt });
+    const body = extractBody(poll.lines);
+    void this.runner(["402-buyer-fulfillment-ack", "-t", tradeNo], {
+      onLine,
+      signal,
+      step: "402-buyer-fulfillment-ack",
+      flow
+    }).catch(() => void 0);
+    return { body, payment: { tradeNo, outTradeNo: reqId }, media };
+  }
+};
+
+// src/client/alipay/router.ts
+init_esm_shims();
+var ALIPAY_RAIL = "alipay";
+function railOf(req) {
+  if (req.scheme === "alipay-aipay" || req.network === ALIPAY_RAIL) return ALIPAY_RAIL;
+  return networkToChainName(req.network) ?? req.network;
+}
+function findRail(accepts, rail) {
+  const requirement = accepts.find((r) => railOf(r) === rail);
+  return requirement ? { rail, requirement } : null;
+}
+function selectRail(input) {
+  const { serverAccepts, explicitRail, preference, availability } = input;
+  if (!serverAccepts || serverAccepts.length === 0) {
+    throw new UnsupportedRailError(explicitRail ?? "unknown", "Server offered no payment options");
+  }
+  if (explicitRail) {
+    const hit = findRail(serverAccepts, explicitRail);
+    if (!hit) {
+      const offered = serverAccepts.map(railOf);
+      throw new UnsupportedRailError(
+        explicitRail,
+        `Server doesn't accept rail '${explicitRail}'. Offered: ${offered.join(", ")}`
+      );
+    }
+    return hit;
+  }
+  if (preference) {
+    for (const pref of preference) {
+      const hit = findRail(serverAccepts, pref);
+      if (hit) return hit;
+    }
+  }
+  if (availability?.evmReady) {
+    const evm = serverAccepts.find((r) => railOf(r) !== ALIPAY_RAIL);
+    if (evm) return { rail: railOf(evm), requirement: evm };
+  }
+  if (availability?.alipayReady) {
+    const hit = findRail(serverAccepts, ALIPAY_RAIL);
+    if (hit) return hit;
+  }
+  return { rail: railOf(serverAccepts[0]), requirement: serverAccepts[0] };
+}
+
+// src/client/types.ts
+init_esm_shims();
+
+// src/client/node/index.ts
 var DEFAULT_CONFIG = {
   chain: "base",
   limits: {
@@ -594,15 +1523,24 @@ var MoltsPayClient = class {
   config;
   walletData = null;
   wallet = null;
+  signer = null;
   todaySpending = 0;
   lastSpendingReset = 0;
+  railPreference;
+  alipaySessionId;
   constructor(options = {}) {
-    this.configDir = options.configDir || join2(homedir2(), ".moltspay");
+    this.configDir = options.configDir || join3(homedir3(), ".moltspay");
     this.config = this.loadConfig();
+    this.railPreference = options.railPreference ?? this.config.railPreference;
+    this.alipaySessionId = options.alipaySessionId;
     this.walletData = this.loadWallet();
     this.loadSpending();
     if (this.walletData) {
-      this.wallet = new Wallet(this.walletData.privateKey);
+      this.wallet = new Wallet2(this.walletData.privateKey);
+      const configDir = this.configDir;
+      this.signer = new NodeSigner(this.wallet, {
+        getSolanaKeypair: () => loadSolanaWallet(configDir)
+      });
     }
   }
   /**
@@ -672,6 +1610,9 @@ var MoltsPayClient = class {
    * @param options - Payment options (token selection)
    */
   async pay(serverUrl, service, params, options = {}) {
+    if (options.rail === ALIPAY_RAIL) {
+      return this.payViaAlipay(serverUrl, service, params, options);
+    }
     if (!this.wallet || !this.walletData) {
       throw new Error("Client not initialized. Run: npx moltspay init");
     }
@@ -730,20 +1671,6 @@ var MoltsPayClient = class {
     } catch {
       throw new Error("Invalid x-payment-required header");
     }
-    const networkToChainName = (network2) => {
-      if (network2 === "solana:mainnet") return "solana";
-      if (network2 === "solana:devnet") return "solana_devnet";
-      const match = network2.match(/^eip155:(\d+)$/);
-      if (!match) return null;
-      const chainId = parseInt(match[1]);
-      if (chainId === 8453) return "base";
-      if (chainId === 137) return "polygon";
-      if (chainId === 84532) return "base_sepolia";
-      if (chainId === 42431) return "tempo_moderato";
-      if (chainId === 56) return "bnb";
-      if (chainId === 97) return "bnb_testnet";
-      return null;
-    };
     const serverChains = requirements.map((r) => networkToChainName(r.network)).filter((c) => c !== null);
     const userSpecifiedChain = options.chain;
     let selectedChain;
@@ -877,6 +1804,76 @@ Please specify: --chain <chain_name>`
     console.log(`[MoltsPay] Success! Payment: ${result.payment?.status || "claimed"}`);
     return result.result || result;
   }
+  /**
+   * Pay for a service over the Alipay fiat rail (2.0.0).
+   *
+   * Unlike the crypto path this needs no EVM wallet — it shells out to
+   * alipay-bot via {@link AlipayClient}. Flow: hit the resource with no
+   * payment to get the 402 challenge, confirm the server actually offers the
+   * alipay rail (selectRail), then run the 8-step state machine and return the
+   * resource body.
+   */
+  async payViaAlipay(serverUrl, service, params, options) {
+    const flow = this.alipaySessionId;
+    let executeUrl = `${serverUrl}/execute`;
+    try {
+      const services = await timeStep(
+        "discover-services",
+        flow,
+        () => this.getServices(serverUrl)
+      );
+      const svc = services.services?.find((s) => s.id === service);
+      if (svc?.endpoint) executeUrl = `${serverUrl}${svc.endpoint}`;
+    } catch {
+    }
+    const requestBody = options.rawData ? { service, ...params } : { service, params };
+    const bodyJson = JSON.stringify(requestBody);
+    const res = await timeStep(
+      "challenge-402",
+      flow,
+      () => fetch(executeUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: bodyJson
+      })
+    );
+    if (res.status !== 402) {
+      const data = await res.json().catch(() => ({}));
+      if (res.ok && data.result) return data.result;
+      throw new Error(data.error || `Expected 402, got ${res.status}`);
+    }
+    const header = res.headers.get(PAYMENT_REQUIRED_HEADER);
+    if (!header) throw new Error("Missing x-payment-required header on 402");
+    const parsed = JSON.parse(Buffer.from(header, "base64").toString("utf-8"));
+    const accepts = Array.isArray(parsed) ? parsed : parsed.accepts ?? [parsed];
+    const { requirement } = selectRail({
+      serverAccepts: accepts,
+      explicitRail: ALIPAY_RAIL,
+      preference: this.railPreference,
+      availability: { evmReady: this.isInitialized }
+    });
+    const onLine = options.onLine ?? ((line) => process.stdout.write(line + "\n"));
+    const alipay = new AlipayClient({
+      sessionId: this.alipaySessionId,
+      configDir: this.configDir
+    });
+    const result = await alipay.pay402({
+      resourceUrl: executeUrl,
+      requirement,
+      method: "POST",
+      data: bodyJson,
+      onLine,
+      onPaymentPending: options.onPaymentPending,
+      timeoutMs: options.timeoutMs,
+      signal: options.signal
+    });
+    try {
+      const json = JSON.parse(result.body);
+      return json.result ?? json;
+    } catch {
+      return { body: result.body, payment: result.payment, media: result.media };
+    }
+  }
   /**
    * Handle MPP (Machine Payments Protocol) payment flow
    * Called when pay() detects WWW-Authenticate header in 402 response
@@ -972,14 +1969,14 @@ Please specify: --chain <chain_name>`
   async handleBNBPayment(executeUrl, service, params, paymentDetails, options = {}) {
     const { to, amount, token, chainName, chain, spender } = paymentDetails;
     const tokenConfig = chain.tokens[token];
-    const provider = new ethers.JsonRpcProvider(chain.rpc);
+    const provider = new ethers2.JsonRpcProvider(chain.rpc);
     const allowance = await this.checkAllowance(tokenConfig.address, spender, provider);
     const amountWeiCheck = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals));
     if (allowance < amountWeiCheck) {
       const nativeBalance = await provider.getBalance(this.wallet.address);
-      const minGasBalance = ethers.parseEther("0.0005");
+      const minGasBalance = ethers2.parseEther("0.0005");
       if (nativeBalance < minGasBalance) {
-        const nativeBNB = parseFloat(ethers.formatEther(nativeBalance)).toFixed(4);
+        const nativeBNB = parseFloat(ethers2.formatEther(nativeBalance)).toFixed(4);
         const isTestnet = chainName === "bnb_testnet";
         if (isTestnet) {
           throw new Error(
@@ -1013,35 +2010,21 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       );
     }
     const amountWei = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
-    const intent = {
+    const intentNonce = Date.now();
+    const intentDeadline = Date.now() + 36e5;
+    const envelope = buildBnbIntentTypedData({
       from: this.wallet.address,
       to,
       amount: amountWei,
-      token: tokenConfig.address,
+      tokenAddress: tokenConfig.address,
       service,
-      nonce: Date.now(),
-      // Use timestamp as nonce for simplicity
-      deadline: Date.now() + 36e5
-      // 1 hour
-    };
-    const domain = {
-      name: "MoltsPay",
-      version: "1",
+      nonce: intentNonce,
+      deadline: intentDeadline,
       chainId: chain.chainId
-    };
-    const types = {
-      PaymentIntent: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "amount", type: "uint256" },
-        { name: "token", type: "address" },
-        { name: "service", type: "string" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ]
-    };
+    });
     console.log(`[MoltsPay] Signing BNB payment intent...`);
-    const signature = await this.wallet.signTypedData(domain, types, intent);
+    const signature = await this.signer.signTypedData(envelope);
+    const intent = envelope.message;
     const network = `eip155:${chain.chainId}`;
     const payload = {
       x402Version: 2,
@@ -1115,12 +2098,11 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       feePayerPubkey
       // Optional fee payer for gasless mode
     );
-    if (feePayerPubkey) {
-      transaction.partialSign(solanaWallet);
-    } else {
-      transaction.sign(solanaWallet);
-    }
-    const signedTx = transaction.serialize({ requireAllSignatures: false }).toString("base64");
+    const unsignedBase64 = transaction.serialize({ requireAllSignatures: false, verifySignatures: false }).toString("base64");
+    const signedTx = await this.signer.signSolanaTransaction({
+      transactionBase64: unsignedBase64,
+      partialSign: !!feePayerPubkey
+    });
     console.log(`[MoltsPay] Transaction signed, sending to server...`);
     const network = chain === "solana" ? "solana:mainnet" : "solana:devnet";
     const payload = {
@@ -1167,7 +2149,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    * Check ERC20 allowance for a spender
    */
   async checkAllowance(tokenAddress, spender, provider) {
-    const contract = new ethers.Contract(
+    const contract = new ethers2.Contract(
       tokenAddress,
       ["function allowance(address owner, address spender) view returns (uint256)"],
       provider
@@ -1178,41 +2160,29 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    * Sign EIP-3009 transferWithAuthorization (GASLESS)
    * This only signs - no on-chain transaction, no gas needed.
    * Supports both USDC and USDT.
+   *
+   * Delegates typed-data construction to `core/eip3009.ts` and the signature
+   * itself to `this.signer`. That way Web Client (Phase 4) can reuse the same
+   * flow with an EIP-1193 signer without duplicating typed-data layout.
    */
   async signEIP3009(to, amount, chain, token = "USDC", domainOverride) {
-    const validAfter = 0;
-    const validBefore = Math.floor(Date.now() / 1e3) + 3600;
-    const nonce = ethers.hexlify(ethers.randomBytes(32));
     const tokenConfig = chain.tokens[token];
     const value = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
-    const authorization = {
+    const nonce = ethers2.hexlify(ethers2.randomBytes(32));
+    const tokenName = domainOverride?.name || tokenConfig.eip712Name || (token === "USDC" ? "USD Coin" : "Tether USD");
+    const tokenVersion = domainOverride?.version || "2";
+    const envelope = buildEIP3009TypedData({
       from: this.wallet.address,
       to,
       value,
-      validAfter: validAfter.toString(),
-      validBefore: validBefore.toString(),
-      nonce
-    };
-    const tokenName = domainOverride?.name || tokenConfig.eip712Name || (token === "USDC" ? "USD Coin" : "Tether USD");
-    const tokenVersion = domainOverride?.version || "2";
-    const domain = {
-      name: tokenName,
-      version: tokenVersion,
+      nonce,
       chainId: chain.chainId,
-      verifyingContract: tokenConfig.address
-    };
-    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 signature = await this.wallet.signTypedData(domain, types, authorization);
-    return { authorization, signature };
+      tokenAddress: tokenConfig.address,
+      tokenName,
+      tokenVersion
+    });
+    const signature = await this.signer.signTypedData(envelope);
+    return { authorization: envelope.message, signature };
   }
   /**
    * Check spending limits
@@ -1244,7 +2214,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
   }
   // --- Config & Wallet Management ---
   loadConfig() {
-    const configPath = join2(this.configDir, "config.json");
+    const configPath = join3(this.configDir, "config.json");
     if (existsSync2(configPath)) {
       const content = readFileSync2(configPath, "utf-8");
       return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
@@ -1253,14 +2223,14 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
   }
   saveConfig() {
     mkdirSync2(this.configDir, { recursive: true });
-    const configPath = join2(this.configDir, "config.json");
+    const configPath = join3(this.configDir, "config.json");
     writeFileSync2(configPath, JSON.stringify(this.config, null, 2));
   }
   /**
    * Load spending data from disk
    */
   loadSpending() {
-    const spendingPath = join2(this.configDir, "spending.json");
+    const spendingPath = join3(this.configDir, "spending.json");
     if (existsSync2(spendingPath)) {
       try {
         const data = JSON.parse(readFileSync2(spendingPath, "utf-8"));
@@ -1283,7 +2253,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    */
   saveSpending() {
     mkdirSync2(this.configDir, { recursive: true });
-    const spendingPath = join2(this.configDir, "spending.json");
+    const spendingPath = join3(this.configDir, "spending.json");
     const data = {
       date: this.lastSpendingReset || (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0),
       amount: this.todaySpending,
@@ -1292,7 +2262,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
     writeFileSync2(spendingPath, JSON.stringify(data, null, 2));
   }
   loadWallet() {
-    const walletPath = join2(this.configDir, "wallet.json");
+    const walletPath = join3(this.configDir, "wallet.json");
     if (existsSync2(walletPath)) {
       if (process.platform !== "win32") {
         try {
@@ -1316,13 +2286,13 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    */
   static init(configDir, options) {
     mkdirSync2(configDir, { recursive: true });
-    const wallet = Wallet.createRandom();
+    const wallet = Wallet2.createRandom();
     const walletData = {
       address: wallet.address,
       privateKey: wallet.privateKey,
       createdAt: Date.now()
     };
-    const walletPath = join2(configDir, "wallet.json");
+    const walletPath = join3(configDir, "wallet.json");
     writeFileSync2(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
     const config = {
       chain: options.chain,
@@ -1331,7 +2301,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
         maxPerDay: options.maxPerDay
       }
     };
-    const configPath = join2(configDir, "config.json");
+    const configPath = join3(configDir, "config.json");
     writeFileSync2(configPath, JSON.stringify(config, null, 2));
     return { address: wallet.address, configDir };
   }
@@ -1348,17 +2318,17 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
     } catch {
       throw new Error(`Unknown chain: ${this.config.chain}`);
     }
-    const provider = new ethers.JsonRpcProvider(chain.rpc);
+    const provider = new ethers2.JsonRpcProvider(chain.rpc);
     const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
     const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
       provider.getBalance(this.wallet.address),
-      new ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
-      new ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+      new ethers2.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+      new ethers2.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
     ]);
     return {
-      usdc: parseFloat(ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
-      usdt: parseFloat(ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
-      native: parseFloat(ethers.formatEther(nativeBalance))
+      usdc: parseFloat(ethers2.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+      usdt: parseFloat(ethers2.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+      native: parseFloat(ethers2.formatEther(nativeBalance))
     };
   }
   /**
@@ -1381,38 +2351,38 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       supportedChains.map(async (chainName) => {
         try {
           const chain = getChain(chainName);
-          const provider = new ethers.JsonRpcProvider(chain.rpc);
+          const provider = new ethers2.JsonRpcProvider(chain.rpc);
           if (chainName === "tempo_moderato") {
             const [nativeBalance, pathUSD, alphaUSD, betaUSD, thetaUSD] = await Promise.all([
               provider.getBalance(this.wallet.address),
-              new ethers.Contract(tempoTokens.pathUSD, tokenAbi, provider).balanceOf(this.wallet.address),
-              new ethers.Contract(tempoTokens.alphaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
-              new ethers.Contract(tempoTokens.betaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
-              new ethers.Contract(tempoTokens.thetaUSD, tokenAbi, provider).balanceOf(this.wallet.address)
+              new ethers2.Contract(tempoTokens.pathUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers2.Contract(tempoTokens.alphaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers2.Contract(tempoTokens.betaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers2.Contract(tempoTokens.thetaUSD, tokenAbi, provider).balanceOf(this.wallet.address)
             ]);
             results[chainName] = {
-              usdc: parseFloat(ethers.formatUnits(pathUSD, 6)),
+              usdc: parseFloat(ethers2.formatUnits(pathUSD, 6)),
               // pathUSD as default USDC
-              usdt: parseFloat(ethers.formatUnits(alphaUSD, 6)),
+              usdt: parseFloat(ethers2.formatUnits(alphaUSD, 6)),
               // alphaUSD as default USDT
-              native: parseFloat(ethers.formatEther(nativeBalance)),
+              native: parseFloat(ethers2.formatEther(nativeBalance)),
               tempo: {
-                pathUSD: parseFloat(ethers.formatUnits(pathUSD, 6)),
-                alphaUSD: parseFloat(ethers.formatUnits(alphaUSD, 6)),
-                betaUSD: parseFloat(ethers.formatUnits(betaUSD, 6)),
-                thetaUSD: parseFloat(ethers.formatUnits(thetaUSD, 6))
+                pathUSD: parseFloat(ethers2.formatUnits(pathUSD, 6)),
+                alphaUSD: parseFloat(ethers2.formatUnits(alphaUSD, 6)),
+                betaUSD: parseFloat(ethers2.formatUnits(betaUSD, 6)),
+                thetaUSD: parseFloat(ethers2.formatUnits(thetaUSD, 6))
               }
             };
           } else {
             const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
               provider.getBalance(this.wallet.address),
-              new ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
-              new ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+              new ethers2.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers2.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
             ]);
             results[chainName] = {
-              usdc: parseFloat(ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
-              usdt: parseFloat(ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
-              native: parseFloat(ethers.formatEther(nativeBalance))
+              usdc: parseFloat(ethers2.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+              usdt: parseFloat(ethers2.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+              native: parseFloat(ethers2.formatEther(nativeBalance))
             };
           }
         } catch (err) {
@@ -1770,16 +2740,40 @@ var CDPFacilitator = class extends BaseFacilitator {
 
 // src/facilitators/tempo.ts
 init_esm_shims();
+import { ethers as ethers3 } from "ethers";
 var TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var TIP20_PERMIT_ABI = [
+  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
+  "function transferFrom(address from, address to, uint256 value) returns (bool)"
+];
 var TempoFacilitator = class extends BaseFacilitator {
   name = "tempo";
   displayName = "Tempo Testnet";
   supportedNetworks = ["eip155:42431"];
   // Tempo Moderato
   rpcUrl;
+  settlerWallet = null;
   constructor() {
     super();
     this.rpcUrl = CHAINS.tempo_moderato.rpc;
+    const settlerKey = process.env.TEMPO_SETTLER_KEY;
+    if (settlerKey) {
+      try {
+        const provider = new ethers3.JsonRpcProvider(this.rpcUrl);
+        this.settlerWallet = new ethers3.Wallet(settlerKey, provider);
+      } catch (err) {
+        console.warn("[TempoFacilitator] Invalid TEMPO_SETTLER_KEY, permit settlement disabled:", err);
+        this.settlerWallet = null;
+      }
+    }
+  }
+  /**
+   * Settler EOA address advertised to clients via `X-Payment-Required.extra.tempoSpender`.
+   * Web Client uses this as the `spender` field in the signed EIP-2612 Permit.
+   * Returns null if no TEMPO_SETTLER_KEY is configured — permit settlement unavailable.
+   */
+  getSpenderAddress() {
+    return this.settlerWallet?.address ?? null;
   }
   async healthCheck() {
     const start = Date.now();
@@ -1804,7 +2798,45 @@ var TempoFacilitator = class extends BaseFacilitator {
       return { healthy: false, error: String(error) };
     }
   }
-  async verify(paymentPayload, requirements) {
+  async verify(paymentPayload, requirements) {
+    const inner = paymentPayload.payload;
+    if (inner && "permit" in inner && inner.permit) {
+      return this.verifyPermit(inner, requirements);
+    }
+    return this.verifyTxHash(paymentPayload, requirements);
+  }
+  /**
+   * Structural validation of an EIP-2612 permit payload. Does NOT submit
+   * anything on-chain — actual submission happens in settlePermit().
+   */
+  async verifyPermit(payload, requirements) {
+    if (!this.settlerWallet) {
+      return { valid: false, error: "Permit settlement not configured (TEMPO_SETTLER_KEY missing)" };
+    }
+    const p = payload.permit;
+    if (!p || !p.owner || !p.spender || !p.value || !p.deadline) {
+      return { valid: false, error: "Invalid permit payload: missing fields" };
+    }
+    if (p.spender.toLowerCase() !== this.settlerWallet.address.toLowerCase()) {
+      return {
+        valid: false,
+        error: `Permit spender ${p.spender} does not match configured settler ${this.settlerWallet.address}`
+      };
+    }
+    const deadline = BigInt(p.deadline);
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    if (deadline <= now) {
+      return { valid: false, error: "Permit deadline has expired" };
+    }
+    if (BigInt(p.value) < BigInt(requirements.amount || "0")) {
+      return {
+        valid: false,
+        error: `Permit value ${p.value} is less than required ${requirements.amount}`
+      };
+    }
+    return { valid: true, details: { scheme: "permit", owner: p.owner } };
+  }
+  async verifyTxHash(paymentPayload, requirements) {
     try {
       const tempoPayload = paymentPayload.payload;
       if (!tempoPayload?.txHash) {
@@ -1862,7 +2894,11 @@ var TempoFacilitator = class extends BaseFacilitator {
     }
   }
   async settle(paymentPayload, requirements) {
-    const verifyResult = await this.verify(paymentPayload, requirements);
+    const inner = paymentPayload.payload;
+    if (inner && "permit" in inner && inner.permit) {
+      return this.settlePermit(inner, requirements);
+    }
+    const verifyResult = await this.verifyTxHash(paymentPayload, requirements);
     if (!verifyResult.valid) {
       return { success: false, error: verifyResult.error };
     }
@@ -1873,6 +2909,52 @@ var TempoFacilitator = class extends BaseFacilitator {
       status: "settled"
     };
   }
+  /**
+   * EIP-2612 permit settlement path. Submits two transactions on Tempo:
+   *   1. pathUSD.permit(owner, spender=settler, value, deadline, v, r, s)
+   *   2. pathUSD.transferFrom(owner, payTo, value)
+   *
+   * The settler EOA pays Tempo gas (via the TIP-20 `feeToken` mechanism — no
+   * native tTEMPO required; any held TIP-20 token balance covers fees).
+   */
+  async settlePermit(payload, requirements) {
+    if (!this.settlerWallet) {
+      return { success: false, error: "Permit settlement not configured (TEMPO_SETTLER_KEY missing)" };
+    }
+    if (!requirements.asset || !requirements.payTo) {
+      return { success: false, error: "Missing asset or payTo in requirements" };
+    }
+    const verifyResult = await this.verifyPermit(payload, requirements);
+    if (!verifyResult.valid) {
+      return { success: false, error: verifyResult.error };
+    }
+    const token = new ethers3.Contract(requirements.asset, TIP20_PERMIT_ABI, this.settlerWallet);
+    const p = payload.permit;
+    try {
+      const permitTx = await token.permit(
+        p.owner,
+        p.spender,
+        p.value,
+        p.deadline,
+        p.v,
+        p.r,
+        p.s
+      );
+      await permitTx.wait();
+      const transferTx = await token.transferFrom(p.owner, requirements.payTo, p.value);
+      await transferTx.wait();
+      return {
+        success: true,
+        transaction: transferTx.hash,
+        status: "settled"
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: `Tempo permit settlement failed: ${err.message}`
+      };
+    }
+  }
   async getTransactionReceipt(txHash) {
     const response = await fetch(this.rpcUrl, {
       method: "POST",
@@ -2116,12 +3198,12 @@ var BNBFacilitator = class extends BaseFacilitator {
     return this.spenderAddress;
   }
   async getServerAddress() {
-    const { ethers: ethers3 } = await import("ethers");
-    const wallet = new ethers3.Wallet(this.serverPrivateKey);
+    const { ethers: ethers5 } = await import("ethers");
+    const wallet = new ethers5.Wallet(this.serverPrivateKey);
     return wallet.address;
   }
   async recoverIntentSigner(intent, chainId) {
-    const { ethers: ethers3 } = await import("ethers");
+    const { ethers: ethers5 } = await import("ethers");
     const domain = {
       ...EIP712_DOMAIN,
       chainId
@@ -2135,7 +3217,7 @@ var BNBFacilitator = class extends BaseFacilitator {
       nonce: intent.nonce,
       deadline: intent.deadline
     };
-    const recoveredAddress = ethers3.verifyTypedData(
+    const recoveredAddress = ethers5.verifyTypedData(
       domain,
       INTENT_TYPES,
       message,
@@ -2179,10 +3261,10 @@ var BNBFacilitator = class extends BaseFacilitator {
     return result.result || "0x0";
   }
   async executeTransferFrom(from, to, amount, token, rpcUrl) {
-    const { ethers: ethers3 } = await import("ethers");
-    const provider = new ethers3.JsonRpcProvider(rpcUrl);
-    const wallet = new ethers3.Wallet(this.serverPrivateKey, provider);
-    const tokenContract = new ethers3.Contract(token, [
+    const { ethers: ethers5 } = await import("ethers");
+    const provider = new ethers5.JsonRpcProvider(rpcUrl);
+    const wallet = new ethers5.Wallet(this.serverPrivateKey, provider);
+    const tokenContract = new ethers5.Contract(token, [
       "function transferFrom(address from, address to, uint256 amount) returns (bool)"
     ], wallet);
     const tx = await tokenContract.transferFrom(from, to, amount);
@@ -2205,9 +3287,381 @@ var BNBFacilitator = class extends BaseFacilitator {
   }
 };
 
+// src/facilitators/alipay.ts
+init_esm_shims();
+import crypto2 from "crypto";
+
+// src/facilitators/alipay/rsa2.ts
+init_esm_shims();
+import crypto from "crypto";
+function rsa2Sign(data, privateKeyPem) {
+  const signer = crypto.createSign("RSA-SHA256");
+  signer.update(data, "utf-8");
+  signer.end();
+  return signer.sign(privateKeyPem, "base64");
+}
+
+// src/facilitators/alipay/encoding.ts
+init_esm_shims();
+function base64url(input) {
+  return Buffer.from(input, "utf-8").toString("base64url");
+}
+function decodeBase64UrlWithPadFix(input) {
+  const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+  return Buffer.from(padded, "base64").toString("utf-8");
+}
+function toPem(key, kind) {
+  const trimmed = key.trim();
+  if (trimmed.includes("-----BEGIN")) return trimmed;
+  const label = kind === "PRIVATE" ? "PRIVATE KEY" : "PUBLIC KEY";
+  const body = trimmed.replace(/\s+/g, "").match(/.{1,64}/g)?.join("\n") ?? "";
+  return `-----BEGIN ${label}-----
+${body}
+-----END ${label}-----
+`;
+}
+
+// src/facilitators/alipay/openapi.ts
+init_esm_shims();
+function formatAlipayTimestamp(d = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function buildSigningString(params) {
+  return Object.keys(params).sort().map((k) => `${k}=${params[k]}`).join("&");
+}
+function responseWrapperKey(method) {
+  return `${method.replace(/\./g, "_")}_response`;
+}
+async function alipayOpenApiCall(method, bizContent, config) {
+  const publicParams = {
+    app_id: config.app_id,
+    method,
+    format: "JSON",
+    charset: "utf-8",
+    sign_type: config.sign_type ?? "RSA2",
+    timestamp: formatAlipayTimestamp(),
+    version: "1.0",
+    biz_content: JSON.stringify(bizContent)
+  };
+  const signingString = buildSigningString(publicParams);
+  const sign = rsa2Sign(signingString, config.private_key_pem);
+  const body = new URLSearchParams({ ...publicParams, sign }).toString();
+  const response = await fetch(config.gateway_url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded;charset=utf-8"
+    },
+    body
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "<unreadable>");
+    throw new Error(
+      `Alipay Open API HTTP ${response.status} for ${method}: ${text.slice(0, 500)}`
+    );
+  }
+  const json = await response.json();
+  const wrapperKey = responseWrapperKey(method);
+  const business = json[wrapperKey];
+  if (business === void 0 || business === null || typeof business !== "object") {
+    throw new Error(
+      `Alipay Open API response missing "${wrapperKey}" wrapper for ${method}: ${JSON.stringify(json).slice(0, 500)}`
+    );
+  }
+  return business;
+}
+
+// src/facilitators/alipay.ts
+var ALIPAY_NETWORK = "alipay";
+var ALIPAY_SCHEME = "alipay-aipay";
+var ALIPAY_GATEWAY_PROD = "https://openapi.alipay.com/gateway.do";
+var ALIPAY_AMOUNT_REGEX = /^\d+(\.\d{1,2})?$/;
+var ALIPAY_PAY_BEFORE_MS = 30 * 60 * 1e3;
+var ALIPAY_SIGNING_FIELDS = [
+  "amount",
+  "currency",
+  "goods_name",
+  "out_trade_no",
+  "pay_before",
+  "resource_id",
+  "seller_id",
+  "service_id"
+];
+var AlipayFacilitator = class extends BaseFacilitator {
+  name = "alipay";
+  displayName = "Alipay AI \u6536";
+  supportedNetworks = [ALIPAY_NETWORK];
+  config;
+  constructor(config) {
+    super();
+    this.config = {
+      gateway_url: ALIPAY_GATEWAY_PROD,
+      sign_type: "RSA2",
+      ...config
+    };
+  }
+  /**
+   * Build the 402 challenge for a service: signs the 8-field payload with
+   * RSA2, packages the nested `{protocol, method}` JSON as Base64URL for
+   * `Payment-Needed`, and emits the parallel x402 `accepts[]` entry.
+   */
+  async createPaymentRequirements(opts) {
+    if (!ALIPAY_AMOUNT_REGEX.test(opts.priceCny)) {
+      throw new Error(
+        `AlipayFacilitator.createPaymentRequirements: priceCny "${opts.priceCny}" does not match /^\\d+(\\.\\d{1,2})?$/ (unit is \u5143, not \u5206; e.g. "1.00" not "100")`
+      );
+    }
+    const now = /* @__PURE__ */ new Date();
+    const outTradeNo = opts.outTradeNo ?? generateOutTradeNo();
+    const payBefore = formatPayBefore(now);
+    const signedFields = {
+      amount: opts.priceCny,
+      currency: "CNY",
+      goods_name: opts.goodsName,
+      out_trade_no: outTradeNo,
+      pay_before: payBefore,
+      resource_id: opts.resourceId,
+      seller_id: this.config.seller_id,
+      service_id: opts.serviceId
+    };
+    const signingString = ALIPAY_SIGNING_FIELDS.map((k) => `${k}=${signedFields[k]}`).join("&");
+    const seller_signature = rsa2Sign(signingString, this.config.private_key_pem);
+    const challenge = {
+      protocol: {
+        out_trade_no: outTradeNo,
+        amount: signedFields.amount,
+        currency: signedFields.currency,
+        resource_id: signedFields.resource_id,
+        pay_before: payBefore,
+        seller_signature,
+        seller_sign_type: this.config.sign_type ?? "RSA2",
+        seller_unique_id: this.config.seller_id
+      },
+      method: {
+        seller_name: this.config.seller_name,
+        seller_id: this.config.seller_id,
+        seller_app_id: this.config.app_id,
+        goods_name: signedFields.goods_name,
+        seller_unique_id_key: "seller_id",
+        service_id: signedFields.service_id
+      }
+    };
+    const paymentNeededHeader = base64url(JSON.stringify(challenge));
+    const x402Accepts = {
+      scheme: ALIPAY_SCHEME,
+      network: ALIPAY_NETWORK,
+      asset: "CNY",
+      amount: opts.priceCny,
+      payTo: this.config.seller_id,
+      maxTimeoutSeconds: ALIPAY_PAY_BEFORE_MS / 1e3,
+      extra: {
+        payment_needed_header: paymentNeededHeader,
+        out_trade_no: outTradeNo,
+        pay_before: payBefore,
+        service_id: signedFields.service_id
+      }
+    };
+    return { x402Accepts, paymentNeededHeader };
+  }
+  /**
+   * Verify a `Payment-Proof` by calling
+   * `alipay.aipay.agent.payment.verify` against the Alipay Open API.
+   *
+   * The proof is conveyed via `paymentPayload.payload`, which may be:
+   * - a raw Base64URL string (the `Payment-Proof` header value), or
+   * - an object `{ paymentProof: string }` / `{ proofHeader: string }`.
+   *
+   * All failure modes (malformed payload, network errors, Alipay
+   * `code != 10000`) return `{ valid: false, error }`. No exception
+   * escapes, regardless of client-supplied input.
+   */
+  async verify(paymentPayload, _requirements) {
+    try {
+      const proofHeader = extractProofHeader(paymentPayload.payload);
+      const decoded = decodeProof(proofHeader);
+      const response = await alipayOpenApiCall(
+        "alipay.aipay.agent.payment.verify",
+        {
+          payment_proof: decoded.protocol.payment_proof,
+          trade_no: decoded.protocol.trade_no,
+          client_session: decoded.method.client_session
+        },
+        this.getOpenApiConfig()
+      );
+      if (response.code !== "10000") {
+        return {
+          valid: false,
+          error: `alipay verify ${response.code}: ${response.sub_msg ?? response.msg ?? "unknown"}`,
+          details: {
+            code: response.code,
+            sub_code: response.sub_code,
+            sub_msg: response.sub_msg
+          }
+        };
+      }
+      return {
+        valid: true,
+        details: {
+          trade_no: response.trade_no ?? decoded.protocol.trade_no,
+          amount: response.amount,
+          out_trade_no: response.out_trade_no,
+          resource_id: response.resource_id,
+          active: response.active
+        }
+      };
+    } catch (e) {
+      return {
+        valid: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  /**
+   * Settle by calling `alipay.aipay.agent.fulfillment.confirm` after the
+   * service resource has been returned to the buyer.
+   *
+   * Per the design (see ALIPAY-INTEGRATION-DESIGN.md §5.1, risk row
+   * "履约确认失败"), this is **fire-and-forget**: the caller (registry /
+   * server) is expected to log fulfillment failures but NOT roll back
+   * the already-delivered resource.
+   *
+   * Re-decodes `paymentPayload.payload` to extract `trade_no` (verify
+   * does the same; the redundant Base64URL decode is negligible).
+   */
+  async settle(paymentPayload, _requirements) {
+    try {
+      const proofHeader = extractProofHeader(paymentPayload.payload);
+      const decoded = decodeProof(proofHeader);
+      const tradeNo = decoded.protocol.trade_no;
+      const response = await alipayOpenApiCall(
+        "alipay.aipay.agent.fulfillment.confirm",
+        { trade_no: tradeNo },
+        this.getOpenApiConfig()
+      );
+      if (response.code !== "10000") {
+        return {
+          success: false,
+          transaction: tradeNo,
+          error: `alipay fulfillment ${response.code}: ${response.sub_msg ?? response.msg ?? "unknown"}`,
+          status: "fulfillment_failed"
+        };
+      }
+      return {
+        success: true,
+        transaction: tradeNo,
+        status: "fulfilled"
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  /**
+   * Validate that the configured RSA keys parse and that the Open API
+   * gateway is reachable. Does NOT make a real business API call (would
+   * burn quota and could appear as a legitimate verify attempt in logs).
+   */
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      crypto2.createPrivateKey(this.config.private_key_pem);
+    } catch (e) {
+      return {
+        healthy: false,
+        error: `merchant private_key_pem parse failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+    try {
+      crypto2.createPublicKey(this.config.alipay_public_key_pem);
+    } catch (e) {
+      return {
+        healthy: false,
+        error: `alipay_public_key_pem parse failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+    const gatewayUrl = this.config.gateway_url ?? ALIPAY_GATEWAY_PROD;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(gatewayUrl, {
+      method: "HEAD",
+      signal: controller.signal
+    }).catch(() => null);
+    clearTimeout(timeout);
+    const latencyMs = Date.now() - start;
+    if (!response) {
+      return { healthy: false, error: `gateway unreachable: ${gatewayUrl}`, latencyMs };
+    }
+    return { healthy: true, latencyMs };
+  }
+  /** Bundle the facilitator config into the shape openapi.ts wants. */
+  getOpenApiConfig() {
+    return {
+      gateway_url: this.config.gateway_url ?? ALIPAY_GATEWAY_PROD,
+      app_id: this.config.app_id,
+      private_key_pem: this.config.private_key_pem,
+      alipay_public_key_pem: this.config.alipay_public_key_pem,
+      sign_type: this.config.sign_type
+    };
+  }
+};
+function generateOutTradeNo() {
+  return "VID" + crypto2.randomBytes(22).toString("base64url").slice(0, 29);
+}
+function formatPayBefore(now) {
+  const expiry = new Date(now.getTime() + ALIPAY_PAY_BEFORE_MS);
+  return expiry.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function extractProofHeader(payload) {
+  if (typeof payload === "string") {
+    if (payload.length === 0) {
+      throw new Error("alipay Payment-Proof is empty");
+    }
+    return payload;
+  }
+  if (payload !== null && typeof payload === "object") {
+    const obj = payload;
+    const candidate = obj.paymentProof ?? obj.proofHeader;
+    if (typeof candidate === "string" && candidate.length > 0) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "alipay payment payload must be a Base64URL string or {paymentProof: string} / {proofHeader: string}"
+  );
+}
+function decodeProof(proofHeader) {
+  let parsed;
+  try {
+    parsed = JSON.parse(decodeBase64UrlWithPadFix(proofHeader));
+  } catch (e) {
+    throw new Error(
+      `failed to decode Payment-Proof: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new Error("decoded Payment-Proof is not an object");
+  }
+  const obj = parsed;
+  const protocol = obj.protocol;
+  const method = obj.method;
+  if (!protocol || typeof protocol.payment_proof !== "string") {
+    throw new Error("decoded Payment-Proof missing protocol.payment_proof");
+  }
+  if (typeof protocol.trade_no !== "string") {
+    throw new Error("decoded Payment-Proof missing protocol.trade_no");
+  }
+  if (!method || typeof method.client_session !== "string") {
+    throw new Error("decoded Payment-Proof missing method.client_session");
+  }
+  return parsed;
+}
+
 // src/facilitators/registry.ts
 init_esm_shims();
-import { Keypair as Keypair4 } from "@solana/web3.js";
+import { Keypair as Keypair5 } from "@solana/web3.js";
 import bs582 from "bs58";
 var FacilitatorRegistry = class {
   factories = /* @__PURE__ */ new Map();
@@ -2223,13 +3677,14 @@ var FacilitatorRegistry = class {
       const feePayerKey = config?.feePayerPrivateKey || process.env.SOLANA_FEE_PAYER_KEY;
       if (feePayerKey) {
         try {
-          feePayerKeypair = Keypair4.fromSecretKey(bs582.decode(feePayerKey));
+          feePayerKeypair = Keypair5.fromSecretKey(bs582.decode(feePayerKey));
         } catch (e) {
           console.warn(`[SolanaFacilitator] Invalid fee payer key: ${e.message}`);
         }
       }
       return new SolanaFacilitator({ feePayerKeypair });
     });
+    this.registerFactory("alipay", (config) => new AlipayFacilitator(config));
     this.selection = selection || { primary: "cdp", fallback: ["tempo", "bnb", "solana"], strategy: "failover" };
   }
   /**
@@ -2457,6 +3912,11 @@ var PAYMENT_RESPONSE_HEADER = "x-payment-response";
 var MPP_AUTH_HEADER = "authorization";
 var MPP_WWW_AUTH_HEADER = "www-authenticate";
 var MPP_RECEIPT_HEADER = "payment-receipt";
+var ALIPAY_PAYMENT_NEEDED_HEADER = "payment-needed";
+var ALIPAY_PAYMENT_PROOF_HEADER = "payment-proof";
+function headerSafe(value) {
+  return String(value ?? "").replace(/[^\x20-\x7E]/g, (ch) => encodeURIComponent(ch)).replace(/"/g, "%22");
+}
 var TOKEN_ADDRESSES = {
   "eip155:8453": {
     USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
@@ -2498,7 +3958,7 @@ var TOKEN_ADDRESSES = {
     // Devnet USDC
   }
 };
-var CHAIN_TO_NETWORK = {
+var CHAIN_TO_NETWORK2 = {
   "base": "eip155:8453",
   "base_sepolia": "eip155:84532",
   "polygon": "eip155:137",
@@ -2529,9 +3989,13 @@ var TOKEN_DOMAINS = {
     USDT: { name: "(PoS) Tether USD", version: "2" }
   },
   // Tempo Moderato testnet - TIP-20 stablecoins
+  // Domain names verified against on-chain DOMAIN_SEPARATOR values on 2026-04-21.
+  // See docs/TEMPO-WEB-SUPPORT.md Section 2 and test/server/tempo-domain.test.ts.
+  // All 4 Tempo TIP-20 tokens (pathUSD / AlphaUSD / BetaUSD / ThetaUSD) use
+  // the token symbol with first letter capitalized + version "1".
   "eip155:42431": {
-    USDC: { name: "pathUSD", version: "1" },
-    USDT: { name: "alphaUSD", version: "1" }
+    USDC: { name: "PathUSD", version: "1" },
+    USDT: { name: "AlphaUSD", version: "1" }
   },
   // BNB Smart Chain mainnet
   "eip155:56": {
@@ -2588,6 +4052,8 @@ var MoltsPayServer = class {
   registry;
   networkId;
   useMainnet;
+  /** Alipay AI 收 facilitator instance, set when `provider.alipay` is configured (2.0.0). */
+  alipayFacilitator = null;
   constructor(servicesPath, options = {}) {
     loadEnvFile2();
     const content = readFileSync4(servicesPath, "utf-8");
@@ -2609,7 +4075,38 @@ var MoltsPayServer = class {
         cdp: { useMainnet: this.useMainnet }
       }
     };
+    const providerAlipay = this.manifest.provider.alipay;
+    if (providerAlipay) {
+      try {
+        const baseDir = path3.dirname(servicesPath);
+        const resolvePem = (p, kind) => toPem(readFileSync4(path3.isAbsolute(p) ? p : path3.resolve(baseDir, p), "utf-8"), kind);
+        const alipayFacilitatorConfig = {
+          seller_id: providerAlipay.seller_id,
+          app_id: providerAlipay.app_id,
+          seller_name: providerAlipay.seller_name,
+          service_id_default: providerAlipay.service_id_default,
+          private_key_pem: resolvePem(providerAlipay.private_key_path, "PRIVATE"),
+          alipay_public_key_pem: resolvePem(providerAlipay.alipay_public_key_path, "PUBLIC"),
+          gateway_url: providerAlipay.gateway_url,
+          sign_type: providerAlipay.sign_type
+        };
+        facilitatorConfig.config = {
+          ...facilitatorConfig.config,
+          alipay: alipayFacilitatorConfig
+        };
+        facilitatorConfig.fallback = facilitatorConfig.fallback || [];
+        if (facilitatorConfig.primary !== "alipay" && !facilitatorConfig.fallback.includes("alipay")) {
+          facilitatorConfig.fallback.push("alipay");
+        }
+      } catch (err) {
+        throw new Error(`[MoltsPay] Alipay rail configured but key load failed: ${err.message}`);
+      }
+    }
     this.registry = new FacilitatorRegistry(facilitatorConfig);
+    if (providerAlipay) {
+      this.alipayFacilitator = this.registry.get("alipay");
+      console.log(`[MoltsPay] Alipay AI \u6536 rail enabled (seller ${providerAlipay.seller_id})`);
+    }
     const primaryFacilitator = this.registry.get(facilitatorConfig.primary);
     console.log(`[MoltsPay] Loaded ${this.manifest.services.length} services from ${servicesPath}`);
     console.log(`[MoltsPay] Provider: ${this.manifest.provider.name}`);
@@ -2654,14 +4151,14 @@ var MoltsPayServer = class {
         const chainName = typeof c === "string" ? c : c.chain;
         const explicitWallet = typeof c === "object" ? c.wallet : null;
         return {
-          network: CHAIN_TO_NETWORK[chainName] || "eip155:8453",
+          network: CHAIN_TO_NETWORK2[chainName] || "eip155:8453",
           wallet: getWalletForChain(chainName, explicitWallet || void 0),
           tokens: (typeof c === "object" ? c.tokens : null) || ["USDC"]
         };
       });
     }
     const chain = provider.chain || "base";
-    const network = CHAIN_TO_NETWORK[chain] || this.networkId;
+    const network = CHAIN_TO_NETWORK2[chain] || this.networkId;
     return [{
       network,
       wallet: getWalletForChain(chain),
@@ -2699,14 +4196,63 @@ var MoltsPayServer = class {
       console.log(`  GET  /health       - Health check (incl. facilitators)`);
     });
   }
+  /**
+   * Apply CORS response headers according to the `cors` option.
+   *
+   * Default (`cors` unset or `true`): `Access-Control-Allow-Origin: *`. Matches 1.5.x behavior
+   * and works for every browser client whose origin does not need to send cookies.
+   *
+   * `cors: false`: emit no CORS headers. Same-origin only.
+   * `cors: string[]`: origin allowlist — echo the origin back iff it matches.
+   * `cors: CorsOptions`: full control (allowlist + credentials + maxAge).
+   *
+   * The required-for-Web response headers are always exposed when CORS is active:
+   * `X-Payment-Required, X-Payment-Response, WWW-Authenticate, Payment-Receipt`.
+   */
+  applyCorsHeaders(req, res) {
+    const cors = this.options.cors;
+    if (cors === false) {
+      return;
+    }
+    const requestOrigin = req.headers.origin ?? "*";
+    if (cors === void 0 || cors === true) {
+      this.writeCorsHeaders(res, "*");
+      return;
+    }
+    if (Array.isArray(cors)) {
+      if (cors.includes(requestOrigin)) {
+        this.writeCorsHeaders(res, requestOrigin);
+        res.setHeader("Vary", "Origin");
+      }
+      return;
+    }
+    const opt = cors;
+    const isAllowed = typeof opt.origins === "function" ? opt.origins(requestOrigin) : opt.origins.includes(requestOrigin);
+    if (!isAllowed) {
+      return;
+    }
+    this.writeCorsHeaders(res, requestOrigin);
+    res.setHeader("Vary", "Origin");
+    if (opt.credentials) {
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    const maxAge = opt.maxAge ?? 600;
+    res.setHeader("Access-Control-Max-Age", String(maxAge));
+  }
+  writeCorsHeaders(res, origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment, Authorization, Payment-Proof");
+    res.setHeader(
+      "Access-Control-Expose-Headers",
+      "X-Payment-Required, X-Payment-Response, WWW-Authenticate, Payment-Receipt, Payment-Needed"
+    );
+  }
   /**
    * Handle incoming request
    */
   async handleRequest(req, res) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment, Authorization");
-    res.setHeader("Access-Control-Expose-Headers", "X-Payment-Required, X-Payment-Response, WWW-Authenticate, Payment-Receipt");
+    this.applyCorsHeaders(req, res);
     if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
@@ -2726,7 +4272,8 @@ var MoltsPayServer = class {
       if (url.pathname === "/execute" && req.method === "POST") {
         const body = await this.readBody(req);
         const paymentHeader = req.headers[PAYMENT_HEADER2];
-        return await this.handleExecute(body, paymentHeader, res);
+        const proofHeader = req.headers[ALIPAY_PAYMENT_PROOF_HEADER];
+        return await this.handleExecute(body, paymentHeader, res, proofHeader);
       }
       if (url.pathname === "/proxy" && req.method === "POST") {
         const clientIP = req.headers["x-real-ip"] || req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket.remoteAddress || "";
@@ -2744,7 +4291,8 @@ var MoltsPayServer = class {
         const body = req.method === "POST" ? await this.readBody(req) : {};
         const authHeader = req.headers[MPP_AUTH_HEADER];
         const x402Header = req.headers[PAYMENT_HEADER2];
-        return await this.handleMPPRequest(skill, body, authHeader, x402Header, res);
+        const proofHeader = req.headers[ALIPAY_PAYMENT_PROOF_HEADER];
+        return await this.handleMPPRequest(skill, body, authHeader, x402Header, res, proofHeader);
       }
       this.sendJson(res, 404, { error: "Not found" });
     } catch (err) {
@@ -2841,7 +4389,7 @@ var MoltsPayServer = class {
   /**
    * POST /execute - Execute service with x402 payment
    */
-  async handleExecute(body, paymentHeader, res) {
+  async handleExecute(body, paymentHeader, res, proofHeader) {
     const { service, params } = body;
     if (!service) {
       return this.sendJson(res, 400, { error: "Missing service" });
@@ -2855,6 +4403,15 @@ var MoltsPayServer = class {
         return this.sendJson(res, 400, { error: `Missing required param: ${key}` });
       }
     }
+    if (proofHeader) {
+      const alipayPayment = {
+        x402Version: X402_VERSION3,
+        scheme: ALIPAY_SCHEME,
+        network: ALIPAY_NETWORK,
+        payload: proofHeader
+      };
+      return this.handleAlipayExecute(skill, params || {}, alipayPayment, res);
+    }
     if (!paymentHeader) {
       return this.sendPaymentRequired(skill.config, res);
     }
@@ -2865,6 +4422,11 @@ var MoltsPayServer = class {
     } catch {
       return this.sendJson(res, 400, { error: "Invalid X-Payment header" });
     }
+    const payScheme = payment.accepted?.scheme || payment.scheme;
+    const payNetwork = payment.accepted?.network || payment.network;
+    if (payScheme === ALIPAY_SCHEME || (payNetwork ? isAlipayChainId(payNetwork) : false)) {
+      return this.handleAlipayExecute(skill, params || {}, payment, res);
+    }
     const validation = this.validatePayment(payment, skill.config);
     if (!validation.valid) {
       return this.sendJson(res, 402, { error: validation.error });
@@ -2929,6 +4491,14 @@ var MoltsPayServer = class {
         console.log(`[MoltsPay] Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
       } catch (err) {
         console.error("[MoltsPay] Settlement failed:", err.message);
+        settlement = { success: false, error: err.message, facilitator: "none" };
+      }
+      if (!settlement?.success) {
+        return this.sendJson(res, 402, {
+          error: "Payment settlement failed",
+          message: settlement?.error || "Settlement returned no success state",
+          facilitator: settlement?.facilitator
+        });
       }
     }
     const responseHeaders = {};
@@ -2949,13 +4519,111 @@ var MoltsPayServer = class {
       payment: settlement?.success ? { transaction: settlement.transaction, status: "settled", facilitator: settlement.facilitator } : { status: "pending" }
     }, responseHeaders);
   }
+  /**
+   * Execute a service paid via the Alipay AI 收 fiat rail (2.0.0).
+   *
+   * Differs from the EVM/SVM path: no token detection, no EIP-3009/permit
+   * validation. Verify hits the Alipay Open API (`payment.verify`). Settlement
+   * (`fulfillment.confirm`) is FIRE-AND-FORGET per ALIPAY-INTEGRATION-DESIGN
+   * §5.1: a confirm failure is logged but does NOT fail the already-delivered
+   * response (the buyer's payment proof was already verified).
+   */
+  async handleAlipayExecute(skill, params, payment, res) {
+    if (!this.alipayFacilitator) {
+      return this.sendJson(res, 402, { error: "Alipay rail not configured on this server" });
+    }
+    const requirements = {
+      scheme: ALIPAY_SCHEME,
+      network: ALIPAY_NETWORK,
+      asset: "CNY",
+      amount: skill.config.alipay?.price_cny || "0",
+      payTo: this.manifest.provider.alipay?.seller_id || "",
+      maxTimeoutSeconds: 1800
+    };
+    console.log(`[MoltsPay] Verifying Alipay payment...`);
+    const verifyResult = await this.registry.verify(payment, requirements);
+    if (!verifyResult.valid) {
+      return this.sendJson(res, 402, {
+        error: `Payment verification failed: ${verifyResult.error}`,
+        facilitator: verifyResult.facilitator
+      });
+    }
+    console.log(`[MoltsPay] Alipay payment verified by ${verifyResult.facilitator}`);
+    const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
+    console.log(`[MoltsPay] Executing skill: ${skill.id} (timeout: ${timeoutSeconds}s)`);
+    let result;
+    try {
+      result = await Promise.race([
+        skill.handler(params),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
+        )
+      ]);
+    } catch (err) {
+      console.error("[MoltsPay] Skill execution failed:", err.message);
+      return this.sendJson(res, 500, {
+        error: "Service execution failed",
+        message: err.message
+      });
+    }
+    let settlement;
+    try {
+      settlement = await this.registry.settle(payment, requirements);
+      if (settlement.success) {
+        console.log(`[MoltsPay] Alipay fulfillment confirmed: ${settlement.transaction}`);
+      } else {
+        console.error(`[MoltsPay] Alipay fulfillment confirm failed (non-fatal): ${settlement.error}`);
+      }
+    } catch (err) {
+      console.error(`[MoltsPay] Alipay fulfillment confirm threw (non-fatal): ${err.message}`);
+      settlement = { success: false, error: err.message, facilitator: "alipay" };
+    }
+    const responseHeaders = {};
+    if (settlement.success) {
+      responseHeaders[PAYMENT_RESPONSE_HEADER] = Buffer.from(JSON.stringify({
+        success: true,
+        transaction: settlement.transaction,
+        network: ALIPAY_NETWORK,
+        facilitator: settlement.facilitator
+      })).toString("base64");
+    }
+    this.sendJson(res, 200, {
+      success: true,
+      result,
+      payment: settlement.success ? { transaction: settlement.transaction, status: "fulfilled", facilitator: settlement.facilitator } : { status: "delivered_unconfirmed", error: settlement.error }
+    }, responseHeaders);
+  }
+  /**
+   * Build the Alipay 402 challenge for a service, or null when the alipay rail
+   * isn't configured for this server or this service. Returns the x402
+   * `accepts[]` entry plus the Base64URL `Payment-Needed` header value so the
+   * 402 responders can dual-emit both the x402 and legacy alipay-bot formats.
+   */
+  async buildAlipayChallenge(config) {
+    if (!this.alipayFacilitator || !config.alipay) return null;
+    try {
+      const req = await this.alipayFacilitator.createPaymentRequirements({
+        serviceId: config.alipay.service_id || this.manifest.provider.alipay.service_id_default,
+        priceCny: config.alipay.price_cny,
+        goodsName: config.alipay.goods_name,
+        resourceId: `/execute?service=${config.id}`
+      });
+      return { accepts: req.x402Accepts, paymentNeededHeader: req.paymentNeededHeader };
+    } catch (err) {
+      console.error(`[MoltsPay] Alipay challenge build failed for ${config.id}: ${err.message}`);
+      return null;
+    }
+  }
   /**
    * Handle MPP (Machine Payments Protocol) request
    * Supports both x402 and MPP protocols on service endpoints
    */
-  async handleMPPRequest(skill, body, authHeader, x402Header, res) {
+  async handleMPPRequest(skill, body, authHeader, x402Header, res, proofHeader) {
     const config = skill.config;
     const params = body || {};
+    if (proofHeader) {
+      return await this.handleExecute({ service: config.id, params }, void 0, res, proofHeader);
+    }
     if (x402Header) {
       return await this.handleExecute({ service: config.id, params }, x402Header, res);
     }
@@ -3061,7 +4729,7 @@ var MoltsPayServer = class {
   /**
    * Return 402 with both x402 and MPP payment requirements
    */
-  sendMPPPaymentRequired(config, res) {
+  async sendMPPPaymentRequired(config, res) {
     const acceptedTokens = getAcceptedCurrencies(config);
     const providerChains = this.getProviderChains();
     const accepts = [];
@@ -3072,6 +4740,10 @@ var MoltsPayServer = class {
         }
       }
     }
+    const alipayChallenge = await this.buildAlipayChallenge(config);
+    if (alipayChallenge) {
+      accepts.push(alipayChallenge.accepts);
+    }
     const x402PaymentRequired = {
       x402Version: X402_VERSION3,
       accepts,
@@ -3099,7 +4771,7 @@ var MoltsPayServer = class {
       };
       const mppRequestEncoded = Buffer.from(JSON.stringify(mppRequest)).toString("base64");
       const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
-      mppWwwAuth = `Payment id="${challengeId}", realm="${this.manifest.provider.name}", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${config.name}", expires="${expiresAt}"`;
+      mppWwwAuth = `Payment id="${challengeId}", realm="${headerSafe(this.manifest.provider.name)}", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${headerSafe(config.name)}", expires="${expiresAt}"`;
     }
     const headers = {
       "Content-Type": "application/problem+json",
@@ -3108,6 +4780,9 @@ var MoltsPayServer = class {
     if (mppWwwAuth) {
       headers[MPP_WWW_AUTH_HEADER] = mppWwwAuth;
     }
+    if (alipayChallenge) {
+      headers[ALIPAY_PAYMENT_NEEDED_HEADER] = alipayChallenge.paymentNeededHeader;
+    }
     res.writeHead(402, headers);
     res.end(JSON.stringify({
       type: "https://paymentauth.org/problems/payment-required",
@@ -3134,7 +4809,7 @@ var MoltsPayServer = class {
    * Return 402 with x402 payment requirements (v2 format)
    * Includes requirements for all chains and all accepted currencies
    */
-  sendPaymentRequired(config, res) {
+  async sendPaymentRequired(config, res) {
     const acceptedTokens = getAcceptedCurrencies(config);
     const providerChains = this.getProviderChains();
     const accepts = [];
@@ -3145,6 +4820,10 @@ var MoltsPayServer = class {
         }
       }
     }
+    const alipayChallenge = await this.buildAlipayChallenge(config);
+    if (alipayChallenge) {
+      accepts.push(alipayChallenge.accepts);
+    }
     const acceptedChains = providerChains.map((c) => {
       if (c.network === "eip155:8453") return "base";
       if (c.network === "eip155:137") return "polygon";
@@ -3162,10 +4841,14 @@ var MoltsPayServer = class {
       }
     };
     const encoded = Buffer.from(JSON.stringify(paymentRequired)).toString("base64");
-    res.writeHead(402, {
+    const headers = {
       "Content-Type": "application/json",
       [PAYMENT_REQUIRED_HEADER2]: encoded
-    });
+    };
+    if (alipayChallenge) {
+      headers[ALIPAY_PAYMENT_NEEDED_HEADER] = alipayChallenge.paymentNeededHeader;
+    }
+    res.writeHead(402, headers);
     res.end(JSON.stringify({
       error: "Payment required",
       message: `Service requires $${config.price} ${config.currency}`,
@@ -3183,7 +4866,7 @@ var MoltsPayServer = class {
     }
     const scheme = payment.accepted?.scheme || payment.scheme;
     const network = payment.accepted?.network || payment.network || this.networkId;
-    if (scheme !== "exact") {
+    if (scheme !== "exact" && scheme !== "permit") {
       return { valid: false, error: `Unsupported scheme: ${scheme}` };
     }
     if (!this.isNetworkAccepted(network)) {
@@ -3205,8 +4888,10 @@ var MoltsPayServer = class {
     const tokenAddresses = TOKEN_ADDRESSES[selectedNetwork] || {};
     const tokenAddress = tokenAddresses[selectedToken];
     const tokenDomain = getTokenDomain(selectedNetwork, selectedToken);
+    const isTempo = selectedNetwork === "eip155:42431";
+    const scheme = isTempo ? "permit" : "exact";
     const requirements = {
-      scheme: "exact",
+      scheme,
       network: selectedNetwork,
       asset: tokenAddress,
       amount: amountInUnits,
@@ -3234,6 +4919,16 @@ var MoltsPayServer = class {
         };
       }
     }
+    if (isTempo) {
+      const tempoFacilitator = this.registry.get("tempo");
+      const tempoSpender = tempoFacilitator?.getSpenderAddress?.();
+      if (tempoSpender) {
+        requirements.extra = {
+          ...requirements.extra || {},
+          tempoSpender
+        };
+      }
+    }
     return requirements;
   }
   /**
@@ -3260,12 +4955,12 @@ var MoltsPayServer = class {
     return accepted.includes(token);
   }
   async readBody(req) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let body = "";
       req.on("data", (chunk) => body += chunk);
       req.on("end", () => {
         try {
-          resolve2(body ? JSON.parse(body) : {});
+          resolve3(body ? JSON.parse(body) : {});
         } catch {
           reject(new Error("Invalid JSON"));
         }
@@ -3368,10 +5063,10 @@ var MoltsPayServer = class {
     }
     const scheme = payment.accepted?.scheme || payment.scheme;
     const network = payment.accepted?.network || payment.network;
-    if (scheme !== "exact") {
+    if (scheme !== "exact" && scheme !== "permit") {
       return this.sendJson(res, 402, { error: `Unsupported scheme: ${scheme}` });
     }
-    const expectedNetwork = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
+    const expectedNetwork = chain ? CHAIN_TO_NETWORK2[chain] || this.networkId : this.networkId;
     if (network !== expectedNetwork) {
       return this.sendJson(res, 402, { error: `Network mismatch: expected ${expectedNetwork}, got ${network}` });
     }
@@ -3523,7 +5218,7 @@ var MoltsPayServer = class {
       };
       const mppRequestEncoded = Buffer.from(JSON.stringify(mppRequest)).toString("base64");
       const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
-      const wwwAuth = `Payment id="${challengeId}", realm="MoltsPay Proxy", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${config.name}", expires="${expiresAt}"`;
+      const wwwAuth = `Payment id="${challengeId}", realm="MoltsPay Proxy", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${headerSafe(config.name)}", expires="${expiresAt}"`;
       res.writeHead(402, {
         "Content-Type": "application/problem+json",
         [MPP_WWW_AUTH_HEADER]: wwwAuth
@@ -3633,7 +5328,7 @@ var MoltsPayServer = class {
   buildProxyPaymentRequirements(config, wallet, token, chain) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
     const acceptedTokens = getAcceptedCurrencies(config);
-    const networkId = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
+    const networkId = chain ? CHAIN_TO_NETWORK2[chain] || this.networkId : this.networkId;
     const selectedToken = token && acceptedTokens.includes(token) ? token : acceptedTokens[0];
     const tokenAddresses = TOKEN_ADDRESSES[networkId] || TOKEN_ADDRESSES[this.networkId] || {};
     const tokenAddress = tokenAddresses[selectedToken];
@@ -3693,10 +5388,10 @@ init_esm_shims();
 async function printQRCode(url) {
   const qrcodeModule = await import("qrcode-terminal");
   const qrcode = qrcodeModule.default || qrcodeModule;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     qrcode.generate(url, { small: true }, (qr) => {
       console.log(qr);
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -3708,9 +5403,9 @@ if (!globalThis.crypto) {
 }
 function getVersion() {
   const locations = [
-    join5(__dirname, "../../package.json"),
-    join5(__dirname, "../package.json"),
-    join5(process.cwd(), "node_modules/moltspay/package.json")
+    join6(__dirname, "../../package.json"),
+    join6(__dirname, "../package.json"),
+    join6(process.cwd(), "node_modules/moltspay/package.json")
   ];
   for (const loc of locations) {
     try {
@@ -3731,7 +5426,7 @@ var ERC20_APPROVE_ABI = [
 ];
 async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = false) {
   const chainConfig = CHAINS[chain];
-  const provider = new ethers2.JsonRpcProvider(chainConfig.rpc);
+  const provider = new ethers4.JsonRpcProvider(chainConfig.rpc);
   const wallet = client.getWallet();
   if (!wallet) {
     console.log("   \u274C No wallet found");
@@ -3740,15 +5435,15 @@ async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = fal
   const signer = wallet.connect(provider);
   console.log(`   Spender: ${spenderAddress}`);
   let bnbBalance = await provider.getBalance(wallet.address);
-  const minGasRequired = ethers2.parseEther("0.0005");
+  const minGasRequired = ethers4.parseEther("0.0005");
   if (bnbBalance < minGasRequired) {
     if (sponsorGas && BNB_SPONSOR_KEY) {
       console.log("   \u23F3 Sponsoring BNB gas for approvals...");
       try {
-        const sponsorWallet = new ethers2.Wallet(BNB_SPONSOR_KEY, provider);
+        const sponsorWallet = new ethers4.Wallet(BNB_SPONSOR_KEY, provider);
         const tx = await sponsorWallet.sendTransaction({
           to: wallet.address,
-          value: ethers2.parseEther("0.001")
+          value: ethers4.parseEther("0.001")
         });
         await tx.wait();
         console.log(`   \u2705 Sponsored 0.001 BNB (tx: ${tx.hash.slice(0, 10)}...)`);
@@ -3767,7 +5462,7 @@ async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = fal
   }
   for (const tokenSymbol of ["USDT", "USDC"]) {
     const tokenConfig = chainConfig.tokens[tokenSymbol];
-    const tokenContract = new ethers2.Contract(tokenConfig.address, ERC20_APPROVE_ABI, signer);
+    const tokenContract = new ethers4.Contract(tokenConfig.address, ERC20_APPROVE_ABI, signer);
     const allowance = await tokenContract.allowance(wallet.address, spenderAddress);
     if (allowance > 0n) {
       console.log(`   \u2705 ${tokenSymbol}: already approved for ${spenderAddress.slice(0, 10)}...`);
@@ -3775,7 +5470,7 @@ async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = fal
     }
     console.log(`   \u23F3 Approving ${tokenSymbol}...`);
     try {
-      const tx = await tokenContract.approve(spenderAddress, ethers2.MaxUint256);
+      const tx = await tokenContract.approve(spenderAddress, ethers4.MaxUint256);
       await tx.wait();
       console.log(`   \u2705 ${tokenSymbol}: approved (tx: ${tx.hash.slice(0, 10)}...)`);
     } catch (err) {
@@ -3786,10 +5481,10 @@ async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = fal
 }
 async function checkBNBApprovals(address, chain, configDir = DEFAULT_CONFIG_DIR2) {
   const chainConfig = CHAINS[chain];
-  const provider = new ethers2.JsonRpcProvider(chainConfig.rpc);
+  const provider = new ethers4.JsonRpcProvider(chainConfig.rpc);
   let spenderAddress = null;
   try {
-    const walletPath = join5(configDir, "wallet.json");
+    const walletPath = join6(configDir, "wallet.json");
     const walletData = JSON.parse(readFileSync5(walletPath, "utf-8"));
     spenderAddress = walletData.approvals?.[chain] || null;
   } catch {
@@ -3800,15 +5495,15 @@ async function checkBNBApprovals(address, chain, configDir = DEFAULT_CONFIG_DIR2
   }
   for (const tokenSymbol of ["USDT", "USDC"]) {
     const tokenConfig = chainConfig.tokens[tokenSymbol];
-    const tokenContract = new ethers2.Contract(tokenConfig.address, ERC20_APPROVE_ABI, provider);
+    const tokenContract = new ethers4.Contract(tokenConfig.address, ERC20_APPROVE_ABI, provider);
     const allowance = await tokenContract.allowance(address, spenderAddress);
     result[tokenSymbol.toLowerCase()] = allowance > 0n;
   }
   return result;
 }
 var program = new Command();
-var DEFAULT_CONFIG_DIR2 = join5(homedir3(), ".moltspay");
-var PID_FILE = join5(DEFAULT_CONFIG_DIR2, "server.pid");
+var DEFAULT_CONFIG_DIR2 = join6(homedir4(), ".moltspay");
+var PID_FILE = join6(DEFAULT_CONFIG_DIR2, "server.pid");
 if (!existsSync5(DEFAULT_CONFIG_DIR2)) {
   mkdirSync3(DEFAULT_CONFIG_DIR2, { recursive: true });
 }
@@ -3817,10 +5512,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve3(answer.trim());
     });
   });
 }
@@ -3848,7 +5543,7 @@ program.command("init").description("Initialize MoltsPay client (create wallet,
     console.log(`
 \u2705 Solana wallet created: ${address}`);
     console.log(`
-\u{1F4C1} Config saved to: ${join5(options.configDir, "wallet-solana.json")}`);
+\u{1F4C1} Config saved to: ${join6(options.configDir, "wallet-solana.json")}`);
     console.log(`
 \u26A0\uFE0F  IMPORTANT: Back up your wallet file!`);
     console.log(`   This file contains your private key!
@@ -3863,7 +5558,7 @@ program.command("init").description("Initialize MoltsPay client (create wallet,
     return;
   }
   console.log("\n\u{1F510} MoltsPay Client Setup\n");
-  if (existsSync5(join5(options.configDir, "wallet.json"))) {
+  if (existsSync5(join6(options.configDir, "wallet.json"))) {
     console.log('\u26A0\uFE0F  EVM wallet already initialized. Use "moltspay config" to update settings.');
     console.log(`   Config dir: ${options.configDir}`);
     return;
@@ -3889,7 +5584,7 @@ program.command("init").description("Initialize MoltsPay client (create wallet,
   console.log(`
 \u{1F4C1} Config saved to: ${result.configDir}`);
   console.log(`
-\u26A0\uFE0F  IMPORTANT: Back up ${join5(result.configDir, "wallet.json")}`);
+\u26A0\uFE0F  IMPORTANT: Back up ${join6(result.configDir, "wallet.json")}`);
   console.log(`   This file contains your private key!
 `);
   if (chain === "bnb" || chain === "bnb_testnet") {
@@ -4054,7 +5749,7 @@ program.command("approve").description("Approve a spender address for BNB chain
 \u{1F510} Approving spender for ${chain}...
 `);
   await setupBNBApprovals(client, chain, options.spender, false);
-  const walletPath = join5(options.configDir || DEFAULT_CONFIG_DIR2, "wallet.json");
+  const walletPath = join6(options.configDir || DEFAULT_CONFIG_DIR2, "wallet.json");
   try {
     const walletData = JSON.parse(readFileSync5(walletPath, "utf-8"));
     walletData.approvals = walletData.approvals || {};
@@ -4691,17 +6386,17 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
   const handlers = /* @__PURE__ */ new Map();
   let provider = null;
   for (const inputPath of allPaths) {
-    const resolvedPath = resolve(inputPath);
+    const resolvedPath = resolve2(inputPath);
     let manifestPath;
     let skillDir;
     let isSkillDir = false;
-    if (existsSync5(join5(resolvedPath, "moltspay.services.json"))) {
-      manifestPath = join5(resolvedPath, "moltspay.services.json");
+    if (existsSync5(join6(resolvedPath, "moltspay.services.json"))) {
+      manifestPath = join6(resolvedPath, "moltspay.services.json");
       skillDir = resolvedPath;
       isSkillDir = true;
     } else if (existsSync5(resolvedPath) && resolvedPath.endsWith(".json")) {
       manifestPath = resolvedPath;
-      skillDir = dirname(resolvedPath);
+      skillDir = dirname2(resolvedPath);
     } else if (existsSync5(resolvedPath)) {
       console.error(`\u274C No moltspay.services.json found in: ${resolvedPath}`);
       continue;
@@ -4718,7 +6413,7 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
       let skillModule = null;
       if (isSkillDir) {
         let entryPoint = "index.js";
-        const pkgJsonPath = join5(skillDir, "package.json");
+        const pkgJsonPath = join6(skillDir, "package.json");
         if (existsSync5(pkgJsonPath)) {
           try {
             const pkgJson = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
@@ -4728,7 +6423,7 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
           } catch {
           }
         }
-        const modulePath = join5(skillDir, entryPoint);
+        const modulePath = join6(skillDir, entryPoint);
         if (existsSync5(modulePath)) {
           try {
             skillModule = await import(modulePath);
@@ -4754,7 +6449,7 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
           const workdir = skillDir;
           handlers.set(service.id, async (params) => {
             return new Promise((resolvePromise, reject) => {
-              const proc = spawn("sh", ["-c", service.command], {
+              const proc = spawn2("sh", ["-c", service.command], {
                 cwd: workdir,
                 stdio: ["pipe", "pipe", "pipe"]
               });
@@ -4807,7 +6502,7 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     provider,
     services: allServices
   };
-  const tempManifestPath = join5(DEFAULT_CONFIG_DIR2, "combined-manifest.json");
+  const tempManifestPath = join6(DEFAULT_CONFIG_DIR2, "combined-manifest.json");
   writeFileSync3(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
   console.log(`
 \u{1F4CB} Combined manifest: ${allServices.length} services`);
@@ -4870,7 +6565,7 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
     }
     process.kill(pid, "SIGTERM");
     console.log("\u2705 Sent SIGTERM to server");
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     try {
       process.kill(pid, 0);
       console.log("\u26A0\uFE0F  Server still running, sending SIGKILL...");
@@ -4886,9 +6581,10 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
     process.exit(1);
   }
 });
-program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <path>", "Image URL or local file path").option("--data <json>", "Raw JSON data to send (for custom input formats)").option("--token <token>", "Token to pay with (USDC or USDT)", "USDC").option("--chain <chain>", "Chain to pay on (base, polygon, base_sepolia, tempo_moderato, solana, or solana_devnet).").option("--config-dir <dir>", "Config directory with wallet.json", DEFAULT_CONFIG_DIR2).option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
+program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <path>", "Image URL or local file path").option("--data <json>", "Raw JSON data to send (for custom input formats)").option("--token <token>", "Token to pay with (USDC or USDT)", "USDC").option("--chain <chain>", "Chain to pay on (base, polygon, base_sepolia, tempo_moderato, solana, or solana_devnet).").option("--rail <rail>", 'Payment rail: a chain name, or "alipay" for the Alipay fiat rail (CNY via alipay-bot)').option("--config-dir <dir>", "Config directory with wallet.json", DEFAULT_CONFIG_DIR2).option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
-  if (!client.isInitialized) {
+  const useAlipay = options.rail?.toLowerCase() === "alipay";
+  if (!useAlipay && !client.isInitialized) {
     console.error("\u274C Wallet not initialized. Run: npx moltspay init");
     process.exit(1);
   }
@@ -4916,7 +6612,7 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
       params.image_url = imagePath;
     } else {
-      const filePath = resolve(imagePath);
+      const filePath = resolve2(imagePath);
       if (!existsSync5(filePath)) {
         console.error(`\u274C Image file not found: ${filePath}`);
         process.exit(1);
@@ -4933,7 +6629,7 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
   }
   const imageDisplay = params.image_url || (params.image_base64 ? `[local file: ${options.image}]` : null);
   const token = (options.token || "USDC").toUpperCase();
-  if (token === "USDT") {
+  if (!useAlipay && token === "USDT") {
     const balance = await client.getBalance();
     if (balance.native < 1e-4) {
       console.log("\n\u26A0\uFE0F  USDT requires a small amount of ETH for gas (~$0.01)");
@@ -4957,13 +6653,31 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
       console.log(`   Prompt: ${params.prompt}`);
     }
     if (imageDisplay) console.log(`   Image: ${imageDisplay}`);
-    console.log(`   Chain: ${chain || "(auto)"}`);
-    console.log(`   Token: ${token}`);
-    console.log(`   Wallet: ${client.address}`);
+    if (useAlipay) {
+      console.log(`   Rail: alipay (CNY via alipay-bot)`);
+    } else {
+      console.log(`   Chain: ${chain || "(auto)"}`);
+      console.log(`   Token: ${token}`);
+      console.log(`   Wallet: ${client.address}`);
+    }
     console.log("");
   }
   try {
-    const result = await client.pay(server, service, params, {
+    const result = await client.pay(server, service, params, useAlipay ? {
+      rail: "alipay",
+      rawData: useRawData,
+      onPaymentPending: ({ paymentUrl, shortenUrl }) => {
+        if (!options.json) {
+          process.stdout.write(`
+\u{1F4F2} \u8BF7\u7528\u652F\u4ED8\u5B9D\u626B\u7801\u6216\u8BBF\u95EE\uFF1A${shortenUrl ?? paymentUrl}
+
+`);
+        }
+      },
+      onLine: (line) => {
+        if (!options.json) process.stdout.write(line + "\n");
+      }
+    } : {
       token,
       chain,
       rawData: useRawData
@@ -4984,11 +6698,34 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     process.exit(1);
   }
 });
+program.command("alipay <action> [args...]").description("Alipay wallet setup via alipay-bot: check | apply | bind").allowUnknownOption().action(async (action, args) => {
+  const map = {
+    check: "check-wallet",
+    apply: "apply-wallet",
+    bind: "bind-wallet"
+  };
+  const sub = map[action] ?? action;
+  const child = spawn2("alipay-bot", [sub, ...args ?? []], {
+    stdio: "inherit",
+    env: filterEnv(process.env)
+  });
+  child.on("error", (e) => {
+    if (e?.code === "ENOENT") {
+      console.error(
+        "\u274C alipay-bot not installed. Run: npx -y @alipay/agent-payment install-cli"
+      );
+    } else {
+      console.error(`\u274C ${e.message}`);
+    }
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code ?? 1));
+});
 program.command("validate <path>").description("Validate a moltspay.services.json file against the schema").action(async (inputPath) => {
-  const resolvedPath = resolve(inputPath);
+  const resolvedPath = resolve2(inputPath);
   let manifestPath;
-  if (existsSync5(join5(resolvedPath, "moltspay.services.json"))) {
-    manifestPath = join5(resolvedPath, "moltspay.services.json");
+  if (existsSync5(join6(resolvedPath, "moltspay.services.json"))) {
+    manifestPath = join6(resolvedPath, "moltspay.services.json");
   } else if (resolvedPath.endsWith(".json") && existsSync5(resolvedPath)) {
     manifestPath = resolvedPath;
   } else {