nansen-cli 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.16.0
+
+### Minor Changes
+
+- [#196](https://github.com/nansen-ai/nansen-cli/pull/196) [`0c286c2`](https://github.com/nansen-ai/nansen-cli/commit/0c286c2d75f977894da8ff18a105aaf21f55f9f2) Thanks [@arein](https://github.com/arein)! - Add Solana WalletConnect support for trading (quote and execute). Solana wallets like Phantom and Solflare can now sign DEX swap transactions via WalletConnect v2.
+
+## 1.15.0
+
+### Minor Changes
+
+- [#216](https://github.com/nansen-ai/nansen-cli/pull/216) [`5b88241`](https://github.com/nansen-ai/nansen-cli/commit/5b882411134efc5ece44d640adc105c8dd8c5771) Thanks [@TimNooren](https://github.com/TimNooren)! - Unified wallet abstraction: Privy server wallets are first-class citizens.
+
+  - `wallet create --provider privy` creates EVM + Solana wallets via Privy and stores a local reference
+  - All wallet commands (list, show, delete, default, send) work by name regardless of provider
+  - Trading (quote + execute) supports Privy wallets with sign-only + Trading API broadcast
+  - x402 auto-payment routes through Privy when credentials are configured
+
+### Patch Changes
+
+- [#232](https://github.com/nansen-ai/nansen-cli/pull/232) [`443aaad`](https://github.com/nansen-ai/nansen-cli/commit/443aaad15da051ac65e0999b4c4b09436050d0fe) Thanks [@kome12](https://github.com/kome12)! - Remove unsupported chains (zksync, unichain) from CLI
+
 ## 1.14.0
 
 ### Minor Changes

package/README.md

@@ -55,7 +55,7 @@ Run `nansen schema --pretty` for the full subcommand and field reference.
 
 ## Supported Chains
 
-`ethereum` `solana` `base` `bnb` `arbitrum` `polygon` `optimism` `avalanche` `linea` `scroll` `zksync` `mantle` `ronin` `sei` `plasma` `sonic` `unichain` `monad` `hyperevm` `iotaevm`
+`ethereum` `solana` `base` `bnb` `arbitrum` `polygon` `optimism` `avalanche` `linea` `scroll` `mantle` `ronin` `sei` `plasma` `sonic` `monad` `hyperevm` `iotaevm`
 
 > Run `nansen schema` to get the current chain list (source of truth).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nansen-cli",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "Command-line interface for Nansen API - designed for AI agents",
   "main": "src/index.js",
   "type": "module",
@@ -21,6 +21,7 @@
     "test:live": "NANSEN_LIVE_TEST=1 vitest run",
     "test:trade": "vitest run --config vitest.e2e.config.js src/__tests__/trade.e2e.test.js",
     "test:send": "vitest run --config vitest.e2e.config.js src/__tests__/send.e2e.test.js",
+    "test:privy": "vitest run --config vitest.e2e.config.js src/__tests__/privy.e2e.test.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "changeset": "changeset",

package/src/api.js

@@ -504,90 +504,133 @@ export class NansenAPI {
           const hasManualSignature = !!(this.defaultHeaders['Payment-Signature'] || options.headers?.['Payment-Signature']);
 
           if (!hasManualSignature) {
-            // 1. Try local wallet with fallback across payment networks
+            // Determine payment method from default wallet's provider
+            let defaultWalletProvider = 'local';
+            let defaultWalletName = 'unknown';
             try {
-              const { createPaymentSignatures } = await import('./x402.js');
-              for await (const { signature, network } of createPaymentSignatures(response, url)) {
-                const paidResponse = await fetch(url, {
-                  method: 'POST',
-                  headers: {
-                    'Content-Type': 'application/json',
-                    'X-Client-Type': 'nansen-cli',
-                    'X-Client-Version': packageVersion,
-                    'Payment-Signature': signature,
-                    ...this.defaultHeaders,
-                    ...options.headers,
-                  },
-                  body: JSON.stringify(NansenAPI.cleanBody(body)),
-                });
-                if (paidResponse.ok) {
-                  const chain = network.startsWith('solana:') ? 'Solana' : 'Base';
-                  console.error(`[x402] Paid via ${chain} USDC`);
-                  // Check remaining balance and warn if low
-                  try {
-                    const { checkX402Balance } = await import('./x402.js');
-                    const balance = await checkX402Balance(network);
-                    if (balance !== null && balance < 0.25) {
-                      console.error(`[x402] Warning: USDC balance low ($${balance.toFixed(2)}). Fund your wallet to avoid interruptions.`);
-                    }
-                  } catch { /* balance check is best-effort */ }
-                  return await paidResponse.json();
-                }
-                // This payment option was rejected, try next
+              const { getWalletConfig, showWallet } = await import('./wallet.js');
+              const walletConfig = getWalletConfig();
+              if (walletConfig.defaultWallet) {
+                defaultWalletName = walletConfig.defaultWallet;
+                const wallet = showWallet(walletConfig.defaultWallet);
+                defaultWalletProvider = wallet.provider || 'local';
               }
-            } catch { /* local wallet unavailable, try WalletConnect */ }
-
-            // 2. Fall back to WalletConnect (walletconnect-x402.js)
-            // (local wallet returns early on success above, so we always reach here if it failed)
-            {
-              let paymentRequirements;
-              const paymentHeader = response.headers.get('payment-required');
-              if (paymentHeader) {
-                try {
-                  paymentRequirements = JSON.parse(atob(paymentHeader));
-                } catch {
-                  data.paymentRequiredRaw = paymentHeader;
+            } catch (err) {
+              if (process.env.DEBUG) console.error(`[x402] Failed to detect wallet provider: ${err.message}`);
+            }
+
+            if (defaultWalletProvider === 'privy') {
+              // Default wallet is Privy: sign via Privy
+              try {
+                const { createPrivyPaymentSignatures } = await import('./privy.js');
+                for await (const { signature, network } of createPrivyPaymentSignatures(response, url)) {
+                  const paidResponse = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                      'Content-Type': 'application/json',
+                      'X-Client-Type': 'nansen-cli',
+                      'X-Client-Version': packageVersion,
+                      'Payment-Signature': signature,
+                      ...this.defaultHeaders,
+                      ...options.headers,
+                    },
+                    body: JSON.stringify(NansenAPI.cleanBody(body)),
+                  });
+                  if (paidResponse.ok) {
+                    console.error(`[x402] Paid via Privy wallet ${defaultWalletName} (${network})`);
+                    try {
+                      const { checkX402Balance } = await import('./x402.js');
+                      const balance = await checkX402Balance(network);
+                      if (balance !== null && balance < 0.25) {
+                        console.error(`[x402] Warning: USDC balance low ($${balance.toFixed(2)}). Fund your wallet to avoid interruptions.`);
+                      }
+                    } catch { /* balance check is best-effort */ }
+                    return await paidResponse.json();
+                  }
                 }
+              } catch (privyErr) {
+                message = `x402 Privy payment failed: ${privyErr.message}`;
               }
-              if (!paymentRequirements && data.paymentRequirements) {
-                paymentRequirements = data.paymentRequirements;
-              }
-
-              if (paymentRequirements) {
-                try {
-                  const { handleX402Payment } = await import('./walletconnect-x402.js');
-                  const paymentSignature = await handleX402Payment(paymentRequirements);
+            } else {
+              // Local wallet or no wallet: existing local wallet + WalletConnect flow
+              // 1. Try local wallet with fallback across payment networks
+              try {
+                const { createPaymentSignatures } = await import('./x402.js');
+                for await (const { signature, network } of createPaymentSignatures(response, url)) {
                   const paidResponse = await fetch(url, {
                     method: 'POST',
                     headers: {
                       'Content-Type': 'application/json',
                       'X-Client-Type': 'nansen-cli',
                       'X-Client-Version': packageVersion,
-                      'Payment-Signature': paymentSignature,
+                      'Payment-Signature': signature,
                       ...this.defaultHeaders,
                       ...options.headers,
                     },
                     body: JSON.stringify(NansenAPI.cleanBody(body)),
                   });
                   if (paidResponse.ok) {
+                    console.error(`[x402] Paid via local wallet ${defaultWalletName} (${network})`);
+                    // Check remaining balance and warn if low
+                    try {
+                      const { checkX402Balance } = await import('./x402.js');
+                      const balance = await checkX402Balance(network);
+                      if (balance !== null && balance < 0.25) {
+                        console.error(`[x402] Warning: USDC balance low ($${balance.toFixed(2)}). Fund your wallet to avoid interruptions.`);
+                      }
+                    } catch { /* balance check is best-effort */ }
                     return await paidResponse.json();
                   }
-                } catch (x402Err) {
-                  if (!this.apiKey) {
-                    // No API key and no payment wallet — guide the user to login rather than
-                    // showing a confusing x402 payment dump they can't act on.
-                    // TODO: full fix would skip x402 entirely when no apiKey is set — see PR #<this PR number>
-                    message = 'No API key configured. Two ways to authenticate:\n' +
-                      '  1. API key: nansen login --api-key <key> (get key at https://app.nansen.ai/api)\n' +
-                      '  2. x402 micropayment: nansen wallet create + fund with USDC (no API key needed)';
-                  } else {
-                    message = `x402 auto-payment failed: ${x402Err.message}`;
+                  // This payment option was rejected, try next
+                }
+              } catch { /* local wallet unavailable, try WalletConnect */ }
+
+              // 2. Fall back to WalletConnect (walletconnect-x402.js)
+              {
+                let paymentRequirements;
+                const paymentHeader = response.headers.get('payment-required');
+                if (paymentHeader) {
+                  try {
+                    paymentRequirements = JSON.parse(atob(paymentHeader));
+                  } catch {
+                    data.paymentRequiredRaw = paymentHeader;
                   }
                 }
-                // Only include raw payment requirements in the error details when the user
-                // has an API key — for unauthenticated users they add noise, not signal.
-                if (this.apiKey) {
-                  data.paymentRequirements = paymentRequirements;
+                if (!paymentRequirements && data.paymentRequirements) {
+                  paymentRequirements = data.paymentRequirements;
+                }
+
+                if (paymentRequirements) {
+                  try {
+                    const { handleX402Payment } = await import('./walletconnect-x402.js');
+                    const paymentSignature = await handleX402Payment(paymentRequirements);
+                    const paidResponse = await fetch(url, {
+                      method: 'POST',
+                      headers: {
+                        'Content-Type': 'application/json',
+                        'X-Client-Type': 'nansen-cli',
+                        'X-Client-Version': packageVersion,
+                        'Payment-Signature': paymentSignature,
+                        ...this.defaultHeaders,
+                        ...options.headers,
+                      },
+                      body: JSON.stringify(NansenAPI.cleanBody(body)),
+                    });
+                    if (paidResponse.ok) {
+                      return await paidResponse.json();
+                    }
+                  } catch (x402Err) {
+                    if (!this.apiKey) {
+                      message = 'No API key configured. Two ways to authenticate:\n' +
+                        '  1. API key: nansen login --api-key <key> (get key at https://app.nansen.ai/api)\n' +
+                        '  2. x402 micropayment: nansen wallet create + fund with USDC (no API key needed)';
+                    } else {
+                      message = `x402 auto-payment failed: ${x402Err.message}`;
+                    }
+                  }
+                  if (this.apiKey) {
+                    data.paymentRequirements = paymentRequirements;
+                  }
                 }
               }
             }

package/src/chain-ids.js

@@ -14,7 +14,6 @@ export const EVM_CHAIN_IDS = {
   bnb: 56,
   linea: 59144,
   scroll: 534352,
-  zksync: 324,
   mantle: 5000,
 };
 
@@ -25,6 +24,6 @@ export const EVM_CHAIN_IDS = {
  */
 export const EVM_CHAINS = [
   'ethereum', 'arbitrum', 'base', 'bnb', 'polygon', 'optimism',
-  'avalanche', 'linea', 'scroll', 'zksync', 'mantle', 'ronin',
-  'sei', 'plasma', 'sonic', 'unichain', 'monad', 'hyperevm', 'iotaevm',
+  'avalanche', 'linea', 'scroll', 'mantle', 'ronin',
+  'sei', 'plasma', 'sonic', 'monad', 'hyperevm', 'iotaevm',
 ];

package/src/cli.js

@@ -686,7 +686,7 @@ EXAMPLES:
   nansen research profiler balance --address 0x... --chain ethereum
   nansen trade quote --chain base --from ETH --to USDC --amount 1000000000000000000
 
-Research chains: ethereum, solana, base, bnb, arbitrum, polygon, optimism, avalanche, linea, scroll, zksync, mantle, ronin, sei, plasma, sonic, unichain, monad, hyperevm, iotaevm
+Research chains: ethereum, solana, base, bnb, arbitrum, polygon, optimism, avalanche, linea, scroll, mantle, ronin, sei, plasma, sonic, monad, hyperevm, iotaevm
 Trade chains: solana, base
 Labels: Fund, Smart Trader, 30D/90D/180D Smart Trader, Smart HL Perps Trader
 

package/src/privy.js

@@ -0,0 +1,359 @@
+/**
+ * Privy Server Wallet Integration
+ *
+ * Two concerns:
+ * 1. PrivyClient - thin REST wrapper for Privy's server wallet API
+ * 2. createPrivyPaymentSignatures - x402 auto-payment via Privy signing
+ */
+
+import fs from "fs";
+import path from "path";
+import { parsePaymentRequirements } from "./x402.js";
+import { isEvmNetwork } from "./x402-evm.js";
+import {
+  isSvmNetwork,
+  getSolanaRpcUrl,
+  fetchRecentBlockhash,
+  buildUnsignedSvmTransaction,
+} from "./x402-svm.js";
+import {
+  buildEIP712TypedData,
+  buildPaymentSignatureHeader,
+} from "./walletconnect-x402.js";
+
+// ============= Constants =============
+
+const PRIVY_BASE_URL = "https://api.privy.io/v1";
+
+// ============= PrivyClient =============
+
+export class PrivyClient {
+  constructor(appId, appSecret) {
+    if (!appId || !appSecret) {
+      throw new Error(
+        "Privy credentials required. Set PRIVY_APP_ID and PRIVY_APP_SECRET environment variables. Get them at https://dashboard.privy.io"
+      );
+    }
+    this.appId = appId;
+    this.appSecret = appSecret;
+    this.baseUrl = PRIVY_BASE_URL;
+  }
+
+  async _request(method, endpoint, body = null) {
+    const auth = Buffer.from(`${this.appId}:${this.appSecret}`).toString(
+      "base64"
+    );
+    const headers = {
+      Authorization: `Basic ${auth}`,
+      "privy-app-id": this.appId,
+      "Content-Type": "application/json",
+    };
+
+    const opts = { method, headers };
+    if (body) opts.body = JSON.stringify(body);
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, opts);
+
+    if (!response.ok) {
+      let msg = `Privy API error: ${response.status}`;
+      try {
+        const data = await response.json();
+        msg = data.message || data.error || msg;
+      } catch { /* non-JSON error response (e.g. 502 from CDN) */ }
+      throw new Error(msg);
+    }
+
+    return await response.json();
+  }
+
+  async createWallet(chainType = "ethereum") {
+    return this._request("POST", "/wallets", { chain_type: chainType });
+  }
+
+  async listWallets() {
+    return this._request("GET", "/wallets");
+  }
+
+  async getWallet(walletId) {
+    return this._request("GET", `/wallets/${walletId}`);
+  }
+
+  async deleteWallet(walletId) {
+    return this._request("DELETE", `/wallets/${walletId}`);
+  }
+
+  async sendTransaction(walletId, { to, value, chainId, data: txData }) {
+    const caip2 = `eip155:${chainId}`;
+    return this._request("POST", `/wallets/${walletId}/rpc`, {
+      method: "eth_sendTransaction",
+      caip2,
+      params: {
+        transaction: {
+          to,
+          value,
+          ...(txData ? { data: txData } : {}),
+        },
+      },
+    });
+  }
+
+  async ethSignTypedDataV4(walletId, typedData) {
+    // Privy uses snake_case "primary_type" instead of "primaryType"
+    const privyTypedData = { ...typedData };
+    if (privyTypedData.primaryType && !privyTypedData.primary_type) {
+      privyTypedData.primary_type = privyTypedData.primaryType;
+      delete privyTypedData.primaryType;
+    }
+    return this._request("POST", `/wallets/${walletId}/rpc`, {
+      method: "eth_signTypedData_v4",
+      params: { typed_data: privyTypedData },
+    });
+  }
+
+  async signEvmTransaction(walletId, transaction) {
+    return this._request("POST", `/wallets/${walletId}/rpc`, {
+      method: "eth_signTransaction",
+      params: { transaction },
+    });
+  }
+
+  async signSolanaTransaction(walletId, transactionBase64) {
+    return this._request("POST", `/wallets/${walletId}/rpc`, {
+      method: "signTransaction",
+      chain_type: "solana",
+      params: { transaction: transactionBase64, encoding: "base64" },
+    });
+  }
+
+}
+
+// ============= Helpers =============
+
+function getClient() {
+  return new PrivyClient(process.env.PRIVY_APP_ID, process.env.PRIVY_APP_SECRET);
+}
+
+/**
+ * Create both an EVM and Solana wallet via Privy and store a local reference file.
+ * Mirrors createWallet() in wallet.js but for Privy server wallets.
+ */
+export async function createPrivyWalletPair(name) {
+  const WALLET_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+  if (!name || !WALLET_NAME_RE.test(name)) {
+    throw new Error("Wallet name must be 1-64 characters: letters, numbers, hyphens, underscores only");
+  }
+
+  const walletsDir = path.join(process.env.HOME || process.env.USERPROFILE || "", ".nansen", "wallets");
+  const walletFile = path.join(walletsDir, `${name}.json`);
+
+  if (fs.existsSync(walletFile)) {
+    throw new Error(`Wallet "${name}" already exists`);
+  }
+
+  const client = getClient();
+  // Create wallets sequentially so we can clean up on partial failure
+  const evmResult = await client.createWallet("ethereum");
+  let solanaResult;
+  try {
+    solanaResult = await client.createWallet("solana");
+  } catch (err) {
+    // Clean up the EVM wallet we just created to avoid orphans
+    try { await client.deleteWallet(evmResult.id); } catch { /* best effort */ }
+    throw err;
+  }
+
+  const walletData = {
+    name,
+    provider: "privy",
+    evm: { privyWalletId: evmResult.id, address: evmResult.address },
+    solana: { privyWalletId: solanaResult.id, address: solanaResult.address },
+    createdAt: new Date().toISOString(),
+  };
+
+  if (!fs.existsSync(walletsDir)) {
+    fs.mkdirSync(walletsDir, { mode: 0o700, recursive: true });
+  }
+
+  // Write config before wallet file so a crash doesn't leave an orphan without a default entry
+  const configPath = path.join(walletsDir, "config.json");
+  let config = { defaultWallet: null, passwordHash: null };
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  }
+  if (!config.defaultWallet) {
+    config.defaultWallet = name;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+  }
+
+  fs.writeFileSync(walletFile, JSON.stringify(walletData, null, 2), { mode: 0o600 });
+
+  return walletData;
+}
+
+// ============= x402 Payment Signing =============
+
+/**
+ * Resolve the EVM wallet for x402 payments.
+ * Priority: PRIVY_WALLET_ID env > default local wallet's privyWalletId > first Privy EVM wallet.
+ */
+async function getPrivyEvmWallet(client) {
+  if (process.env.PRIVY_WALLET_ID) {
+    return client.getWallet(process.env.PRIVY_WALLET_ID);
+  }
+
+  // Prefer the wallet referenced by the local default wallet file
+  try {
+    const walletsDir = path.join(process.env.HOME || process.env.USERPROFILE || "", ".nansen", "wallets");
+    const configPath = path.join(walletsDir, "config.json");
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (config.defaultWallet) {
+        const walletFile = path.join(walletsDir, `${config.defaultWallet}.json`);
+        if (fs.existsSync(walletFile)) {
+          const data = JSON.parse(fs.readFileSync(walletFile, "utf8"));
+          if (data.provider === "privy" && data.evm?.privyWalletId) {
+            return client.getWallet(data.evm.privyWalletId);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    // Fall through to list-based detection
+    if (process.env.DEBUG) console.error(`[x402] Default wallet lookup failed: ${err.message}`);
+  }
+
+  const result = await client.listWallets();
+  const wallets = result.data || result.wallets || result;
+  if (!Array.isArray(wallets)) return null;
+  return wallets.find((w) => w.chain_type === "ethereum") || null;
+}
+
+/**
+ * Resolve the Solana wallet for x402 payments.
+ * Priority: default local wallet's solana.privyWalletId > first Privy Solana wallet.
+ */
+async function getPrivySolanaWallet(client) {
+  try {
+    const walletsDir = path.join(process.env.HOME || process.env.USERPROFILE || "", ".nansen", "wallets");
+    const configPath = path.join(walletsDir, "config.json");
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (config.defaultWallet) {
+        const walletFile = path.join(walletsDir, `${config.defaultWallet}.json`);
+        if (fs.existsSync(walletFile)) {
+          const data = JSON.parse(fs.readFileSync(walletFile, "utf8"));
+          if (data.provider === "privy" && data.solana?.privyWalletId) {
+            return client.getWallet(data.solana.privyWalletId);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[x402] Solana wallet lookup failed: ${err.message}`);
+  }
+
+  const result = await client.listWallets();
+  const wallets = result.data || result.wallets || result;
+  if (!Array.isArray(wallets)) return null;
+  return wallets.find((w) => w.chain_type === "solana") || null;
+}
+
+/**
+ * Generate payment signatures for x402 using Privy server wallets.
+ * Same yield contract as createPaymentSignatures() in x402.js: { signature, network }
+ *
+ * @param {Response} response - The 402 HTTP response
+ * @param {string} url - The original request URL
+ * @returns {AsyncGenerator<{ signature: string, network: string }>}
+ */
+export async function* createPrivyPaymentSignatures(response, url) {
+  const requirements = parsePaymentRequirements(response);
+  if (!requirements || requirements.length === 0) return;
+
+  const client = getClient();
+
+  // EVM requirements
+  const evmRequirements = requirements.filter((r) => isEvmNetwork(r.network));
+  if (evmRequirements.length > 0) {
+    const evmWallet = await getPrivyEvmWallet(client);
+    if (evmWallet) {
+      for (const requirement of evmRequirements) {
+        try {
+          const typedData = buildEIP712TypedData({
+            fromAddress: evmWallet.address,
+            requirement,
+          });
+
+          const signResult = await client.ethSignTypedDataV4(
+            evmWallet.id,
+            typedData
+          );
+          const signature = signResult.data?.signature || signResult.signature;
+
+          const authorization = {
+            from: evmWallet.address,
+            to: requirement.payTo,
+            value: (requirement.amount || requirement.maxAmountRequired).toString(),
+            validAfter: typedData.message.validAfter.toString(),
+            validBefore: typedData.message.validBefore.toString(),
+            nonce: typedData.message.nonce,
+          };
+
+          const header = buildPaymentSignatureHeader({
+            signature,
+            authorization,
+            resource: { url, description: "", mimeType: "" },
+            accepted: requirement,
+          });
+
+          yield { signature: header, network: requirement.network };
+        } catch (err) {
+          console.error(`[x402] Privy EVM signing failed for ${requirement.network}: ${err.message}`);
+          continue;
+        }
+      }
+    } else {
+      console.error('[x402] No Privy EVM wallet found for payment signing');
+    }
+  }
+
+  // Solana requirements
+  const svmRequirements = requirements.filter((r) => isSvmNetwork(r.network));
+  if (svmRequirements.length > 0) {
+    const solWallet = await getPrivySolanaWallet(client);
+    if (solWallet) {
+      for (const requirement of svmRequirements) {
+        try {
+          const rpcUrl = getSolanaRpcUrl(requirement.network);
+          const recentBlockhash = await fetchRecentBlockhash(rpcUrl);
+
+          const { txBase64 } = buildUnsignedSvmTransaction(
+            requirement,
+            solWallet.address,
+            recentBlockhash,
+          );
+
+          const signResult = await client.signSolanaTransaction(solWallet.id, txBase64);
+          const signedTx = signResult.data?.signed_transaction || signResult.signed_transaction;
+
+          const payload = {
+            x402Version: 2,
+            payload: { transaction: signedTx },
+            accepted: requirement,
+          };
+          if (url) {
+            payload.resource = { url };
+          }
+
+          const header = Buffer.from(JSON.stringify(payload)).toString("base64");
+          yield { signature: header, network: requirement.network };
+        } catch (err) {
+          console.error(`[x402] Privy Solana signing failed for ${requirement.network}: ${err.message}`);
+          continue;
+        }
+      }
+    } else {
+      console.error('[x402] No Privy Solana wallet found for payment signing');
+    }
+  }
+}