mpp-test-sdk 1.0.0 → 1.1.1

package/dist/index.js

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   MppError: () => MppError,
   MppFaucetError: () => MppFaucetError,
+  MppNetworkError: () => MppNetworkError,
   MppPaymentError: () => MppPaymentError,
   MppTimeoutError: () => MppTimeoutError,
   createTestClient: () => createTestClient,
@@ -31,8 +32,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_accounts = require("viem/accounts");
-var import_client = require("mppx/client");
+var import_web3 = require("@solana/web3.js");
 
 // src/errors.ts
 var MppError = class extends Error {
@@ -44,7 +44,9 @@ var MppError = class extends Error {
 var MppFaucetError = class extends MppError {
   address;
   constructor(address, cause) {
-    super(`Failed to fund wallet ${address} from testnet faucet`);
+    super(
+      `Failed to airdrop SOL to wallet ${address}. The devnet/testnet faucet may be rate-limited. Wait 30s and retry, or pass a pre-funded secretKey to skip airdrop.`
+    );
     this.name = "MppFaucetError";
     this.address = address;
     this.cause = cause;
@@ -65,95 +67,201 @@ var MppTimeoutError = class extends MppError {
   url;
   timeoutMs;
   constructor(url, timeoutMs) {
-    super(`Request to ${url} timed out after ${timeoutMs}ms`);
+    super(`Request to ${url} timed out after ${timeoutMs}ms. Increase the timeout option or check your Solana RPC connection.`);
     this.name = "MppTimeoutError";
     this.url = url;
     this.timeoutMs = timeoutMs;
   }
 };
+var MppNetworkError = class extends MppError {
+  network;
+  constructor(network, message) {
+    super(
+      message ?? `Network configuration error for "${network}". Mainnet requires a pre-funded secretKey (no airdrop available).`
+    );
+    this.name = "MppNetworkError";
+    this.network = network;
+  }
+};
 
 // src/client.ts
-var FAUCET_RPC = "https://rpc.testnet.tempo.xyz";
-async function fundWallet(address) {
-  const res = await fetch(FAUCET_RPC, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tempo_fundAddress",
-      params: [address]
-    })
-  });
-  if (!res.ok) {
-    throw new MppFaucetError(address, new Error(`HTTP ${res.status}`));
+var NETWORK_RPC = {
+  devnet: "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  mainnet: "https://api.mainnet-beta.solana.com"
+};
+var AIRDROP_NETWORKS = ["devnet", "testnet"];
+async function airdropWithRetry(connection, publicKey, retries = 3) {
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      const sig = await connection.requestAirdrop(publicKey, 2 * import_web3.LAMPORTS_PER_SOL);
+      await connection.confirmTransaction(sig, "confirmed");
+      return;
+    } catch (err) {
+      if (attempt === retries - 1) {
+        throw new MppFaucetError(publicKey.toBase58(), err);
+      }
+      await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt)));
+    }
   }
-  const json = await res.json();
-  if (json.error) {
-    throw new MppFaucetError(address, new Error(json.error.message ?? "RPC error"));
+}
+function parseHeaderParams(header) {
+  const params = {};
+  const parts = header.split(";").map((s) => s.trim());
+  for (const part of parts.slice(1)) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx > 0) {
+      const key = part.slice(0, eqIdx).trim().toLowerCase();
+      const val = part.slice(eqIdx + 1).trim().replace(/^"|"$/g, "");
+      params[key] = val;
+    }
+  }
+  return params;
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
   }
+  return controller.signal;
 }
 async function createTestClient(config) {
   const emit = config?.onStep ?? (() => {
   });
   const timeout = config?.timeout ?? 3e4;
-  const key = config?.privateKey ?? (0, import_accounts.generatePrivateKey)();
-  const account = (0, import_accounts.privateKeyToAccount)(key);
+  const network = config?.network ?? "devnet";
+  const rpcUrl = config?.rpcUrl ?? NETWORK_RPC[network];
+  if (network === "mainnet" && !config?.secretKey) {
+    throw new MppNetworkError(
+      "mainnet",
+      "createTestClient: mainnet requires a pre-funded secretKey. Airdrop is not available on mainnet. Pass your keypair's secretKey in the config."
+    );
+  }
+  const keypair = config?.secretKey ? import_web3.Keypair.fromSecretKey(config.secretKey) : import_web3.Keypair.generate();
+  const connection = new import_web3.Connection(rpcUrl, "confirmed");
+  const address = keypair.publicKey.toBase58();
   emit({
     type: "wallet-created",
-    message: `Wallet ${account.address}`,
-    data: { address: account.address }
-  });
-  await fundWallet(account.address);
-  emit({ type: "funded", message: "Wallet funded on testnet" });
-  const mppxClient = import_client.Mppx.create({
-    methods: [(0, import_client.tempo)({ account, testnet: true })]
+    message: `Wallet ${address}`,
+    data: { address, network }
   });
-  return {
-    address: account.address,
-    method: "tempo",
-    fetch: async (url, init) => {
-      emit({ type: "request", message: `\u2192 ${url}` });
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeout);
-      const signal = init?.signal ? anySignal([init.signal, controller.signal]) : controller.signal;
-      try {
-        const response = await mppxClient.fetch(url, { ...init, signal });
-        if (!response.ok && response.status !== 402) {
+  if (AIRDROP_NETWORKS.includes(network)) {
+    await airdropWithRetry(connection, keypair.publicKey);
+    emit({
+      type: "funded",
+      message: `Wallet funded via ${network} airdrop (2 SOL)`,
+      data: { network, amount: 2 }
+    });
+  } else {
+    emit({
+      type: "funded",
+      message: "Using pre-funded mainnet wallet",
+      data: { network }
+    });
+  }
+  const clientFetch = async (url, init) => {
+    emit({ type: "request", message: `\u2192 ${url}`, data: { url } });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    const signal = init?.signal ? anySignal([init.signal, controller.signal]) : controller.signal;
+    try {
+      const res = await fetch(url, { ...init, signal });
+      if (res.status !== 402) {
+        if (!res.ok) {
           emit({
             type: "error",
-            message: `\u2190 ${response.status}`,
-            data: { status: response.status }
+            message: `\u2190 ${res.status} ${res.statusText}`,
+            data: { status: res.status }
           });
-          throw new MppPaymentError(url, response.status);
+          throw new MppPaymentError(url, res.status);
         }
         emit({
-          type: response.ok ? "success" : "payment",
-          message: `\u2190 ${response.status}`,
-          data: { status: response.status }
+          type: "success",
+          message: `\u2190 ${res.status} OK`,
+          data: { status: res.status }
         });
-        return response;
-      } catch (err) {
-        if (err instanceof Error && err.name === "AbortError") {
-          throw new MppTimeoutError(url, timeout);
+        return res;
+      }
+      const paymentRequestHeader = res.headers.get("payment-request");
+      if (!paymentRequestHeader) {
+        throw new MppPaymentError(url, 402, new Error("Server returned 402 without Payment-Request header"));
+      }
+      const params = parseHeaderParams(paymentRequestHeader);
+      if (!params.recipient) {
+        throw new MppPaymentError(url, 402, new Error("Payment-Request header missing recipient field"));
+      }
+      if (!params.amount) {
+        throw new MppPaymentError(url, 402, new Error("Payment-Request header missing amount field"));
+      }
+      const recipient = new import_web3.PublicKey(params.recipient);
+      const amountSol = parseFloat(params.amount);
+      if (isNaN(amountSol) || amountSol <= 0) {
+        throw new MppPaymentError(url, 402, new Error(`Invalid payment amount: ${params.amount}`));
+      }
+      const lamports = Math.round(amountSol * import_web3.LAMPORTS_PER_SOL);
+      emit({
+        type: "payment",
+        message: `Paying ${amountSol} SOL \u2192 ${params.recipient.slice(0, 8)}...`,
+        data: { amount: amountSol, recipient: params.recipient }
+      });
+      const { blockhash } = await connection.getLatestBlockhash("confirmed");
+      const tx = new import_web3.Transaction({
+        recentBlockhash: blockhash,
+        feePayer: keypair.publicKey
+      }).add(
+        import_web3.SystemProgram.transfer({
+          fromPubkey: keypair.publicKey,
+          toPubkey: recipient,
+          lamports
+        })
+      );
+      const signature = await (0, import_web3.sendAndConfirmTransaction)(connection, tx, [keypair], {
+        commitment: "confirmed"
+      });
+      emit({
+        type: "payment",
+        message: `Confirmed: ${signature.slice(0, 16)}...`,
+        data: { signature, amount: amountSol }
+      });
+      emit({
+        type: "retry",
+        message: `\u2191 Retrying with payment proof`,
+        data: { signature }
+      });
+      const existingHeaders = init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init?.headers ?? {};
+      const retryRes = await fetch(url, {
+        ...init,
+        signal,
+        headers: {
+          ...existingHeaders,
+          "payment-receipt": `solana; signature="${signature}"; network="${network}"; amount="${amountSol}"`
         }
-        throw err;
-      } finally {
-        clearTimeout(timer);
+      });
+      emit({
+        type: retryRes.ok ? "success" : "error",
+        message: `\u2190 ${retryRes.status} ${retryRes.ok ? "OK" : retryRes.statusText}`,
+        data: { status: retryRes.status, signature }
+      });
+      return retryRes;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new MppTimeoutError(url, timeout);
       }
+      throw err;
+    } finally {
+      clearTimeout(timer);
     }
   };
-}
-function anySignal(signals) {
-  const controller = new AbortController();
-  for (const signal of signals) {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return controller.signal;
-    }
-    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
-  }
-  return controller.signal;
+  return {
+    address,
+    network,
+    method: "solana",
+    fetch: clientFetch
+  };
 }
 var _sharedClient = null;
 async function mppFetch(url, init) {
@@ -167,32 +275,112 @@ mppFetch.reset = () => {
 };
 
 // src/server.ts
-var import_express = require("mppx/express");
-var import_accounts2 = require("viem/accounts");
-var PATHUSD = "0x20c0000000000000000000000000000000000000";
-function createTestServer(config) {
-  if (!config.secretKey) {
-    throw new Error("createTestServer: secretKey is required");
+var import_web32 = require("@solana/web3.js");
+var NETWORK_RPC2 = {
+  devnet: "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  mainnet: "https://api.mainnet-beta.solana.com"
+};
+function parseHeaderParams2(header) {
+  const params = {};
+  const parts = header.split(";").map((s) => s.trim());
+  for (const part of parts.slice(1)) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx > 0) {
+      const key = part.slice(0, eqIdx).trim().toLowerCase();
+      const val = part.slice(eqIdx + 1).trim().replace(/^"|"$/g, "");
+      params[key] = val;
+    }
   }
-  const serverKey = config.privateKey ?? (0, import_accounts2.generatePrivateKey)();
-  const serverAccount = (0, import_accounts2.privateKeyToAccount)(serverKey);
-  const mppx = import_express.Mppx.create({
-    secretKey: config.secretKey,
-    methods: [
-      (0, import_express.tempo)({
-        testnet: true,
-        currency: config.currency ?? PATHUSD,
-        recipient: serverAccount.address,
-        account: serverAccount
-      })
-    ]
-  });
-  return mppx;
+  return params;
+}
+function createTestServer(config = {}) {
+  const network = config.network ?? "devnet";
+  const rpcUrl = config.rpcUrl ?? NETWORK_RPC2[network];
+  const serverKeypair = config.secretKey ? import_web32.Keypair.fromSecretKey(config.secretKey) : import_web32.Keypair.generate();
+  const recipientAddress = config.recipientAddress ?? serverKeypair.publicKey.toBase58();
+  const connection = new import_web32.Connection(rpcUrl, "confirmed");
+  const charge = ({ amount }) => async (req, res, next) => {
+    const receiptHeader = req.headers["payment-receipt"] ?? "";
+    if (!receiptHeader) {
+      res.status(402).set(
+        "Payment-Request",
+        `solana; amount="${amount}"; recipient="${recipientAddress}"; network="${network}"`
+      ).json({
+        error: "Payment Required",
+        payment: {
+          amount,
+          currency: "SOL",
+          recipient: recipientAddress,
+          network
+        }
+      });
+      return;
+    }
+    try {
+      const params = parseHeaderParams2(receiptHeader);
+      const { signature } = params;
+      if (!signature) {
+        res.status(403).json({ error: "Payment-Receipt missing signature field" });
+        return;
+      }
+      const paidAmount = parseFloat(params.amount ?? "0");
+      const requiredAmount = parseFloat(amount);
+      if (isNaN(paidAmount) || paidAmount < requiredAmount) {
+        res.status(403).json({
+          error: `Insufficient payment: claimed ${params.amount ?? "0"} SOL, required ${amount} SOL`
+        });
+        return;
+      }
+      const tx = await connection.getParsedTransaction(signature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (!tx) {
+        res.status(403).json({ error: "Transaction not found on chain" });
+        return;
+      }
+      if (tx.meta?.err) {
+        res.status(403).json({ error: "Transaction failed on chain" });
+        return;
+      }
+      const accountKeys = tx.transaction.message.accountKeys;
+      const preBalances = tx.meta?.preBalances ?? [];
+      const postBalances = tx.meta?.postBalances ?? [];
+      const recipientPubkey = new import_web32.PublicKey(recipientAddress);
+      const recipientIdx = accountKeys.findIndex(
+        (k) => k.pubkey.toBase58() === recipientPubkey.toBase58()
+      );
+      if (recipientIdx < 0) {
+        res.status(403).json({
+          error: `Recipient ${recipientAddress.slice(0, 8)}... not found in transaction`
+        });
+        return;
+      }
+      const received = (postBalances[recipientIdx] - preBalances[recipientIdx]) / import_web32.LAMPORTS_PER_SOL;
+      if (received < requiredAmount) {
+        res.status(403).json({
+          error: `Payment too small: received ${received} SOL, required ${requiredAmount} SOL`
+        });
+        return;
+      }
+      next();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      res.status(403).json({ error: `Payment verification failed: ${message}` });
+    }
+  };
+  return {
+    charge,
+    recipientAddress,
+    network
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MppError,
   MppFaucetError,
+  MppNetworkError,
   MppPaymentError,
   MppTimeoutError,
   createTestClient,