@vue-solana/core 4.0.0 → 4.1.0

package/README.md

@@ -46,6 +46,7 @@ Full Vue Solana docs:
 - iOS browser wallet link helpers for supported wallets.
 - Transaction submission and confirmation helpers.
 - SPL token account reads through Kit RPC `jsonParsed`.
+- Solana Pay transfer request URL encoding and parsing plus QR rendering, implemented directly on Kit.
 - A framework-agnostic action state machine (`createSolanaActionStore`) for async Solana work with per-attempt `AbortSignal` handling.
 
 ## Compatibility
@@ -164,30 +165,36 @@ Direct subpaths:
 - `@vue-solana/core/mobile-wallet-support`
 - `@vue-solana/core/rpc`
 - `@vue-solana/core/token-accounts`
+- `@vue-solana/core/solana-pay`
+- `@vue-solana/core/solana-pay-confirmation`
+- `@vue-solana/core/solana-pay-status`
 - `@vue-solana/core/timeout`
 - `@vue-solana/core/transaction`
 - `@vue-solana/core/wallet`
 - `@vue-solana/core/wallet-standard`
 
-| API                                                             | Description                                                                                                                                                                |
-| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `DEFAULT_CLUSTER`                                               | Default cluster, currently `devnet`.                                                                                                                                       |
-| `parseAddress(value)`                                           | Parses an `Address`, address string, ref-like `{ value }`, getter, `null`, or `undefined` into an `Address \| null`. Invalid strings throw `INVALID_ADDRESS`.              |
-| `createSolanaClient(config?)`                                   | Creates a Kit client exposing `rpc`, `rpcSubscriptions`, the official transaction planner, and the official RPC transaction-sending executor.                              |
-| `createSolanaContext(config?)`                                  | Creates `{ cluster, endpoint, wsEndpoint, client }`.                                                                                                                       |
-| `getClusterEndpoint(cluster?)`                                  | Returns the HTTP RPC endpoint for a cluster.                                                                                                                               |
-| `getClusterWebSocketEndpoint(cluster?)`                         | Returns the WebSocket endpoint for a cluster.                                                                                                                              |
-| `getWebSocketEndpoint(endpoint)`                                | Converts `http`/`https` RPC URLs to `ws`/`wss` URLs.                                                                                                                       |
-| `isWalletConnected(wallet)`                                     | Checks whether a wallet is connected and has an address.                                                                                                                   |
-| `assertWalletConnected(wallet)`                                 | Throws if the wallet is not connected.                                                                                                                                     |
-| `assertWalletCanSignMessage(wallet)`                            | Throws if the wallet is disconnected or cannot sign messages.                                                                                                              |
-| `assertWalletCanSign(wallet)`                                   | Throws if the wallet cannot sign transactions.                                                                                                                             |
-| `signAndSendTransaction(client, wallet, transaction, options?)` | Signs and sends raw wire bytes (`SolanaTransaction = Uint8Array`) using a configured wallet.                                                                               |
-| `confirmTransactionSignature(client, signature, options?)`      | Waits for a submitted signature to reach a requested commitment by polling `getSignatureStatuses`. Defaults to `confirmed` and a 60 second timeout.                        |
-| `getTokenAccountsByOwner(client, owner, options?)`              | Returns SPL token accounts for an owner (token and token-2022 programs by default).                                                                                        |
-| `getTokenAccount(client, address, commitment?)`                 | Reads a single token account, returning `null` when it does not exist.                                                                                                     |
-| `getTokenBalance(client, mint, owner, commitment?)`             | Reads the token balance for an owner's associated token account as `{ amount, decimals }`.                                                                                 |
-| `createSolanaActionStore(fn)`                                   | Wraps an async `(signal, ...args) => Promise` function into a `{ getState, subscribe, dispatch, reset, withSignal }` store; each dispatch aborts the prior in-flight call. |
+| API                                                             | Description                                                                                                                                                                          |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `DEFAULT_CLUSTER`                                               | Default cluster, currently `devnet`.                                                                                                                                                 |
+| `parseAddress(value)`                                           | Parses an `Address`, address string, ref-like `{ value }`, getter, `null`, or `undefined` into an `Address \| null`. Invalid strings throw `INVALID_ADDRESS`.                        |
+| `createSolanaClient(config?)`                                   | Creates a Kit client exposing `rpc`, `rpcSubscriptions`, the official transaction planner, and the official RPC transaction-sending executor.                                        |
+| `createSolanaContext(config?)`                                  | Creates `{ cluster, endpoint, wsEndpoint, client }`.                                                                                                                                 |
+| `getClusterEndpoint(cluster?)`                                  | Returns the HTTP RPC endpoint for a cluster.                                                                                                                                         |
+| `getClusterWebSocketEndpoint(cluster?)`                         | Returns the WebSocket endpoint for a cluster.                                                                                                                                        |
+| `getWebSocketEndpoint(endpoint)`                                | Converts `http`/`https` RPC URLs to `ws`/`wss` URLs.                                                                                                                                 |
+| `isWalletConnected(wallet)`                                     | Checks whether a wallet is connected and has an address.                                                                                                                             |
+| `assertWalletConnected(wallet)`                                 | Throws if the wallet is not connected.                                                                                                                                               |
+| `assertWalletCanSignMessage(wallet)`                            | Throws if the wallet is disconnected or cannot sign messages.                                                                                                                        |
+| `assertWalletCanSign(wallet)`                                   | Throws if the wallet cannot sign transactions.                                                                                                                                       |
+| `signAndSendTransaction(client, wallet, transaction, options?)` | Signs and sends raw wire bytes (`SolanaTransaction = Uint8Array`) using a configured wallet.                                                                                         |
+| `confirmTransactionSignature(client, signature, options?)`      | Waits for a submitted signature to reach a requested commitment by polling `getSignatureStatuses`. Defaults to `confirmed` and a 60 second timeout.                                  |
+| `getTokenAccountsByOwner(client, owner, options?)`              | Returns SPL token accounts for an owner (token and token-2022 programs by default).                                                                                                  |
+| `getTokenAccount(client, address, commitment?)`                 | Reads a single token account, returning `null` when it does not exist.                                                                                                               |
+| `getTokenBalance(client, mint, owner, commitment?)`             | Reads the token balance for an owner's associated token account as `{ amount, decimals }`.                                                                                           |
+| `encodeURL(fields)`                                             | Builds a `solana:` transfer or transaction request URL from Kit `Address` values; transfer amounts are `bigint` lamports encoded as decimal SOL.                                     |
+| `parseURL(value)`                                               | Parses a transfer request into typed `recipient`, `amount`, `splToken`, `reference`, `label`, `message`, and `memo` fields, or a transaction request `link`. Throws `ParseURLError`. |
+| `createQR(url, size?, background?, color?)`                     | Renders a Solana Pay URL as an SVG string; `createQRDataURL()` and `createQRCanvas()` cover the other render targets. The `qrcode` encoder loads lazily.                             |
+| `createSolanaActionStore(fn)`                                   | Wraps an async `(signal, ...args) => Promise` function into a `{ getState, subscribe, dispatch, reset, withSignal }` store; each dispatch aborts the prior in-flight call.           |
 
 The client-sent API is the official Kit `ClientWithTransactionSending` capability installed by `createSolanaClient()`. It does not use a wallet popup; `sent` is reached after the RPC executor completes its send-and-confirm operation at `confirmed` commitment. Use a `payer`, and keep funded keys in a trusted server or relayer context.
 | `registerSolanaMobileWallet(config?)` | Registers an Android Mobile Wallet Adapter wallet through `@solana-mobile/wallet-standard-mobile`. |

package/dist/index.d.ts

@@ -8,7 +8,10 @@ export { TokenAccountInfo, TokenAccountsByOwnerOptions, TokenBalanceResult, getT
 export { confirmTransactionSignature, signAndSendTransaction } from './transaction.js';
 export { WithTimeoutOptions, withSolanaTimeout, withTimeout } from './timeout.js';
 export { SolanaWalletError, SolanaWalletErrorCode, assertWalletCanSign, assertWalletCanSignAndSendTransactions, assertWalletCanSignIn, assertWalletCanSignMessage, assertWalletCanSignTransactions, assertWalletConnected, createNoWalletSelectedError, isWalletConnected } from './wallet.js';
+export { SolanaPayVerificationOptions, SolanaPayVerificationResult, createSolanaPayReference, findTransactionSignaturesByReference, verifySolanaPayPayment } from './solana-pay-confirmation.js';
+export { SolanaPayPaymentStatus, getSolanaPayPaymentStatus } from './solana-pay-status.js';
 export * from '@solana/kit';
 export { AdaptSolanaWalletOptions, AdaptedSolanaWallet, SOLANA_CHAINS, SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, adaptSolanaStandardWallet, disconnectSolanaStandardWallet, getRegisteredSolanaWallets, getSolanaChain, isSolanaStandardWallet, subscribeSolanaWallets } from './wallet-standard.js';
+export { Amount, CreateTransferError, HTTPS_PROTOCOL, Label, Link, MEMO_PROGRAM_ID, Memo, Message, ParseURLError, QROptions, Recipient, Reference, References, SOLANA_PROTOCOL, SOL_DECIMALS, SPLToken, TEN, TOKEN_PROGRAM_ID, TransactionRequestURLFields, TransferRequestURLFields, createQR, createQRCanvas, createQRDataURL, createQROptions, createRecipient, createSPLToken, createStyledQRCode, encodeTransactionRequestURL, encodeTransferRequestURL, encodeURL, isValidSolanaAddress, parseURL } from './solana-pay.js';
 import '@solana/kit-plugin-rpc';
 import '@wallet-standard/base';

package/dist/index.mjs

@@ -8,5 +8,8 @@ export { getTokenAccount, getTokenAccountsByOwner, getTokenBalance } from './tok
 export { confirmTransactionSignature, signAndSendTransaction } from './transaction.mjs';
 export { withSolanaTimeout, withTimeout } from './timeout.mjs';
 export { SolanaWalletError, assertWalletCanSign, assertWalletCanSignAndSendTransactions, assertWalletCanSignIn, assertWalletCanSignMessage, assertWalletCanSignTransactions, assertWalletConnected, createNoWalletSelectedError, isWalletConnected } from './wallet.mjs';
+export { createSolanaPayReference, findTransactionSignaturesByReference, verifySolanaPayPayment } from './solana-pay-confirmation.mjs';
+export { getSolanaPayPaymentStatus } from './solana-pay-status.mjs';
 export * from '@solana/kit';
+export { C as CreateTransferError, H as HTTPS_PROTOCOL, M as MEMO_PROGRAM_ID, P as ParseURLError, S as SOLANA_PROTOCOL, a as SOL_DECIMALS, T as TEN, b as TOKEN_PROGRAM_ID, c as createQR, d as createQRCanvas, e as createQRDataURL, f as createQROptions, g as createRecipient, h as createSPLToken, i as createStyledQRCode, j as encodeTransactionRequestURL, k as encodeTransferRequestURL, l as encodeURL, m as isValidSolanaAddress, p as parseURL } from './shared/core.CQFtdLrA.mjs';
 export { S as SOLANA_CHAINS, a as SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, b as adaptSolanaStandardWallet, d as disconnectSolanaStandardWallet, g as getRegisteredSolanaWallets, c as getSolanaChain, i as isSolanaStandardWallet, s as subscribeSolanaWallets } from './shared/core.A4I__4IR.mjs';

package/dist/shared/core.CQFtdLrA.mjs

@@ -0,0 +1,334 @@
+import { address } from '@solana/kit';
+
+const SOLANA_PROTOCOL = "solana:";
+const HTTPS_PROTOCOL = "https:";
+const MEMO_PROGRAM_ID = address("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+const TOKEN_PROGRAM_ID = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const SOL_DECIMALS = 9;
+const TEN = 10n;
+
+class CreateTransferError extends Error {
+  name = "CreateTransferError";
+}
+
+function lamportsToDecimal(amount, decimals = SOL_DECIMALS) {
+  const neg = amount < 0n;
+  const abs = neg ? -amount : amount;
+  const base = 10n ** BigInt(decimals);
+  const int = abs / base;
+  const frac = abs % base;
+  if (frac === 0n) return `${neg ? "-" : ""}${int}`;
+  const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${neg ? "-" : ""}${int}.${fracStr}`;
+}
+function encodeURL(fields) {
+  if ("link" in fields) {
+    return encodeTransactionRequestURL(fields);
+  }
+  return encodeTransferRequestURL(fields);
+}
+function encodeTransferRequestURL({
+  recipient,
+  amount,
+  splToken,
+  reference,
+  label,
+  message,
+  memo
+}) {
+  const url = new URL(SOLANA_PROTOCOL + recipient.toString());
+  if (amount !== void 0) {
+    url.searchParams.append("amount", lamportsToDecimal(amount, SOL_DECIMALS));
+  }
+  if (splToken) {
+    url.searchParams.append("spl-token", splToken.toString());
+  }
+  if (reference) {
+    const references = Array.isArray(reference) ? reference : [reference];
+    for (const ref of references) {
+      url.searchParams.append("reference", ref.toString());
+    }
+  }
+  if (label) {
+    url.searchParams.append("label", label);
+  }
+  if (message) {
+    url.searchParams.append("message", message);
+  }
+  if (memo) {
+    url.searchParams.append("memo", memo);
+  }
+  return url;
+}
+function encodeTransactionRequestURL({
+  link,
+  label,
+  message
+}) {
+  const pathname = String(link).replace(/\/\?/, "?").replace(/\/$/, "");
+  const url = pathname.startsWith("http") ? new URL(pathname) : new URL(SOLANA_PROTOCOL + pathname);
+  if (url.protocol !== SOLANA_PROTOCOL && url.protocol !== HTTPS_PROTOCOL) {
+    throw new Error("invalid link");
+  }
+  if (label) {
+    url.searchParams.append("label", label);
+  }
+  if (message) {
+    url.searchParams.append("message", message);
+  }
+  return url;
+}
+
+class ParseURLError extends Error {
+  name = "ParseURLError";
+}
+function toAtomicUnits(amount, decimals) {
+  if (!amount || !amount.trim()) {
+    throw new ParseURLError("amount invalid");
+  }
+  const trimmed = amount.trim();
+  if (trimmed.startsWith("-")) {
+    throw new ParseURLError("amount invalid");
+  }
+  const [integerPart = "0", fractionalPart = ""] = trimmed.split(".");
+  if ((integerPart === "" || integerPart === "0") && fractionalPart === "") {
+    throw new ParseURLError("amount invalid");
+  }
+  if (fractionalPart.length > decimals) {
+    throw new ParseURLError("amount decimals invalid");
+  }
+  const paddedFractional = fractionalPart.padEnd(decimals, "0");
+  const integerLamports = BigInt(integerPart || "0") * 10n ** BigInt(decimals);
+  const fractionalLamports = BigInt(paddedFractional || "0");
+  return integerLamports + fractionalLamports;
+}
+function parseURL(url) {
+  if (typeof url === "string") {
+    if (url.length > 2048) throw new ParseURLError("length invalid");
+    url = new URL(url);
+  }
+  if (url.protocol !== SOLANA_PROTOCOL) throw new ParseURLError("protocol invalid");
+  if (!url.pathname) throw new ParseURLError("pathname missing");
+  if (/^https?:\/\//.test(url.pathname)) {
+    return parseTransactionRequestURL(url);
+  }
+  return parseTransferRequestURL(url);
+}
+function parseTransferRequestURL(url) {
+  const { pathname, searchParams } = url;
+  let recipient;
+  try {
+    recipient = address(pathname);
+  } catch {
+    throw new ParseURLError("recipient invalid");
+  }
+  let amount;
+  const amountParam = searchParams.get("amount");
+  if (amountParam != null) {
+    if (!/^\d+(\.\d+)?$/.test(amountParam)) throw new ParseURLError("amount invalid");
+    if (Number.isNaN(Number.parseFloat(amountParam))) throw new ParseURLError("amount invalid");
+    amount = toAtomicUnits(amountParam, SOL_DECIMALS);
+  }
+  let splToken;
+  const splTokenParam = searchParams.get("spl-token");
+  if (splTokenParam != null) {
+    try {
+      splToken = address(splTokenParam);
+    } catch {
+      throw new ParseURLError("token invalid");
+    }
+  }
+  const referenceParams = searchParams.getAll("reference");
+  let reference;
+  if (referenceParams.length) {
+    try {
+      reference = referenceParams.map((param) => address(param));
+    } catch {
+      throw new ParseURLError("reference invalid");
+    }
+  }
+  const label = searchParams.get("label") || void 0;
+  const message = searchParams.get("message") || void 0;
+  const memo = searchParams.get("memo") || void 0;
+  return {
+    recipient,
+    amount,
+    splToken,
+    reference,
+    label,
+    message,
+    memo
+  };
+}
+function parseTransactionRequestURL(url) {
+  let link;
+  try {
+    const linkParam = url.pathname.slice(2);
+    link = new URL(decodeURIComponent(linkParam) + url.search);
+    if (link.protocol !== HTTPS_PROTOCOL) throw new ParseURLError("link invalid");
+  } catch {
+    throw new ParseURLError("link invalid");
+  }
+  const label = url.searchParams.get("label") || void 0;
+  const message = url.searchParams.get("message") || void 0;
+  return {
+    link,
+    label,
+    message
+  };
+}
+
+async function loadQRCode() {
+  const mod = await import('qrcode');
+  return mod.default ?? mod;
+}
+function createQROptions(_url, size = 512, background = "white", color = "black") {
+  return {
+    width: size,
+    margin: 2,
+    color: {
+      dark: color,
+      light: background
+    },
+    errorCorrectionLevel: "Q",
+    dotStyle: "rounded",
+    cornerStyle: "extra-rounded"
+  };
+}
+async function createStyledQRCode(url, options) {
+  const QRCode = await loadQRCode();
+  const qrMatrix = QRCode.create(String(url), {
+    errorCorrectionLevel: options.errorCorrectionLevel ?? "Q"
+  });
+  const size = options.width ?? 512;
+  const margin = options.margin ?? 2;
+  const moduleCount = qrMatrix.modules.size;
+  const cellSize = (size - margin * 2) / moduleCount;
+  const dotSize = cellSize * 0.8;
+  const darkColor = options.color?.dark ?? "black";
+  const lightColor = options.color?.light ?? "white";
+  let svg = `<svg width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" xmlns="http://www.w3.org/2000/svg">`;
+  svg += `<rect width="${size}" height="${size}" fill="${lightColor}"/>`;
+  const isFinderPattern = (row, col) => {
+    if (row < 7 && col < 7) return true;
+    if (row < 7 && col >= moduleCount - 7) return true;
+    if (row >= moduleCount - 7 && col < 7) return true;
+    return false;
+  };
+  const drawFinderPattern = (centerX, centerY) => {
+    const patternSize = 7 * cellSize;
+    const innerSize = 3 * cellSize;
+    const middleSize = 5 * cellSize;
+    let outerRadius = cellSize;
+    let middleRadius = cellSize * 0.5;
+    let innerRadius = cellSize * 0.3;
+    switch (options.cornerStyle) {
+      case "square":
+        outerRadius = 0;
+        middleRadius = 0;
+        innerRadius = 0;
+        break;
+      case "rounded":
+        outerRadius = cellSize * 0.5;
+        middleRadius = cellSize * 0.3;
+        innerRadius = cellSize * 0.2;
+        break;
+      case "extra-rounded":
+        outerRadius = cellSize;
+        middleRadius = cellSize * 0.5;
+        innerRadius = cellSize * 0.3;
+        break;
+      case "full-rounded":
+        outerRadius = cellSize * 1.5;
+        middleRadius = cellSize * 0.8;
+        innerRadius = cellSize * 0.5;
+        break;
+      case "maximum-rounded":
+        outerRadius = cellSize * 2;
+        middleRadius = cellSize * 1.2;
+        innerRadius = cellSize * 0.8;
+        break;
+    }
+    svg += `<rect x="${centerX}" y="${centerY}" width="${patternSize}" height="${patternSize}" fill="${darkColor}" rx="${outerRadius}" ry="${outerRadius}"/>`;
+    svg += `<rect x="${centerX + cellSize}" y="${centerY + cellSize}" width="${middleSize}" height="${middleSize}" fill="${lightColor}" rx="${middleRadius}" ry="${middleRadius}"/>`;
+    svg += `<rect x="${centerX + 2 * cellSize}" y="${centerY + 2 * cellSize}" width="${innerSize}" height="${innerSize}" fill="${darkColor}" rx="${innerRadius}" ry="${innerRadius}"/>`;
+  };
+  drawFinderPattern(margin, margin);
+  drawFinderPattern(margin + (moduleCount - 7) * cellSize, margin);
+  drawFinderPattern(margin, margin + (moduleCount - 7) * cellSize);
+  for (let row = 0; row < moduleCount; row++) {
+    for (let col = 0; col < moduleCount; col++) {
+      if (!qrMatrix.modules.get(row, col) || isFinderPattern(row, col)) continue;
+      const x = margin + col * cellSize + (cellSize - dotSize) / 2;
+      const y = margin + row * cellSize + (cellSize - dotSize) / 2;
+      if (options.dotStyle === "dots") {
+        svg += `<circle cx="${x + dotSize / 2}" cy="${y + dotSize / 2}" r="${dotSize / 2}" fill="${darkColor}"/>`;
+      } else if (options.dotStyle === "rounded") {
+        const radius = dotSize * 0.3;
+        svg += `<rect x="${x}" y="${y}" width="${dotSize}" height="${dotSize}" fill="${darkColor}" rx="${radius}" ry="${radius}"/>`;
+      } else {
+        svg += `<rect x="${x}" y="${y}" width="${dotSize}" height="${dotSize}" fill="${darkColor}"/>`;
+      }
+    }
+  }
+  if (options.logo) {
+    const logoSize = options.logoSize ?? size * 0.2;
+    const logoMargin = options.logoMargin ?? 8;
+    const logoX = (size - logoSize) / 2;
+    const logoY = (size - logoSize) / 2;
+    if (options.logoBackgroundColor) {
+      const bgSize = logoSize + logoMargin * 2;
+      const bgX = (size - bgSize) / 2;
+      const bgY = (size - bgSize) / 2;
+      svg += `<rect x="${bgX}" y="${bgY}" width="${bgSize}" height="${bgSize}" fill="${options.logoBackgroundColor}" rx="${logoMargin}" ry="${logoMargin}"/>`;
+    }
+    svg += `<image x="${logoX}" y="${logoY}" width="${logoSize}" height="${logoSize}" href="${options.logo}" preserveAspectRatio="xMidYMid meet"/>`;
+  }
+  svg += "</svg>";
+  return svg;
+}
+async function createQR(url, size = 512, background = "white", color = "black") {
+  return createStyledQRCode(url, createQROptions(url, size, background, color));
+}
+async function createQRDataURL(url, options) {
+  const svg = await createStyledQRCode(url, options);
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+async function createQRCanvas(canvas, url, options) {
+  const QRCode = await loadQRCode();
+  await QRCode.toCanvas(canvas, String(url), {
+    width: options.width,
+    margin: options.margin,
+    color: options.color,
+    errorCorrectionLevel: options.errorCorrectionLevel
+  });
+}
+
+function createSPLToken(tokenAddress) {
+  try {
+    return address(tokenAddress);
+  } catch (error) {
+    throw new Error(`Invalid SPL token address: ${tokenAddress}. ${String(error)}`, {
+      cause: error
+    });
+  }
+}
+function createRecipient(recipientAddress) {
+  try {
+    return address(recipientAddress);
+  } catch (error) {
+    throw new Error(`Invalid recipient address: ${recipientAddress}. ${String(error)}`, {
+      cause: error
+    });
+  }
+}
+function isValidSolanaAddress(addr) {
+  try {
+    address(addr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { CreateTransferError as C, HTTPS_PROTOCOL as H, MEMO_PROGRAM_ID as M, ParseURLError as P, SOLANA_PROTOCOL as S, TEN as T, SOL_DECIMALS as a, TOKEN_PROGRAM_ID as b, createQR as c, createQRCanvas as d, createQRDataURL as e, createQROptions as f, createRecipient as g, createSPLToken as h, createStyledQRCode as i, encodeTransactionRequestURL as j, encodeTransferRequestURL as k, encodeURL as l, isValidSolanaAddress as m, parseURL as p };

package/dist/solana-pay-confirmation.d.ts

@@ -0,0 +1,23 @@
+import { Address } from '@solana/kit';
+
+declare function createSolanaPayReference(): Promise<Address>;
+declare function findTransactionSignaturesByReference(rpc: unknown, reference: string): Promise<unknown>;
+interface SolanaPayVerificationOptions {
+    reference: string;
+    expectedRecipient: string;
+    expectedAmount?: bigint;
+    expectedTokenMint?: string;
+    commitment?: "processed" | "confirmed" | "finalized";
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+interface SolanaPayVerificationResult {
+    status: "pending" | "found" | "confirmed" | "finalized" | "expired" | "error";
+    signature?: string;
+    verified: boolean;
+    reason?: string;
+}
+declare function verifySolanaPayPayment(rpc: unknown, options: SolanaPayVerificationOptions): Promise<SolanaPayVerificationResult>;
+
+export { createSolanaPayReference, findTransactionSignaturesByReference, verifySolanaPayPayment };
+export type { SolanaPayVerificationOptions, SolanaPayVerificationResult };

package/dist/solana-pay-confirmation.mjs

@@ -0,0 +1,97 @@
+import { generateKeyPairSigner } from '@solana/kit';
+
+async function createSolanaPayReference() {
+  const signer = await generateKeyPairSigner();
+  return signer.address;
+}
+async function findTransactionSignaturesByReference(rpc, reference) {
+  const res = await rpc.getSignaturesForAddress(reference).send();
+  return res;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function verifySolanaPayPayment(rpc, options) {
+  const {
+    reference,
+    expectedRecipient,
+    expectedAmount,
+    expectedTokenMint,
+    commitment = "confirmed",
+    timeoutMs = 3e4,
+    pollIntervalMs = 1e3
+  } = options;
+  const deadline = Date.now() + timeoutMs;
+  let signature;
+  while (Date.now() < deadline) {
+    try {
+      const sigs = await findTransactionSignaturesByReference(rpc, reference);
+      if (Array.isArray(sigs) && sigs.length > 0) {
+        signature = sigs[0].signature;
+        break;
+      }
+    } catch {
+      return { status: "error", verified: false, reason: "rpc_failure" };
+    }
+    await sleep(pollIntervalMs);
+  }
+  if (!signature) {
+    return { status: "expired", verified: false, reason: "no_payment_found" };
+  }
+  try {
+    const tx = await rpc.getTransaction(signature, { encoding: "jsonParsed", commitment }).send();
+    if (!tx) {
+      return { status: "pending", verified: false, signature, reason: "transaction_not_found" };
+    }
+    if (tx.meta?.err) {
+      return { status: "error", verified: false, signature, reason: "transaction_failed" };
+    }
+    const confStatus = commitment === "finalized" ? "finalized" : "confirmed";
+    const instructions = tx.transaction?.message?.instructions ?? [];
+    let matched = false;
+    if (!expectedTokenMint) {
+      for (const ix of instructions) {
+        const parsed = ix.parsed;
+        if (parsed?.type === "transfer" && parsed.info?.destination === expectedRecipient) {
+          if (expectedAmount !== void 0) {
+            const lamports = BigInt(
+              parsed.info.lamports ?? 0
+            );
+            if (lamports === expectedAmount) matched = true;
+          } else {
+            matched = true;
+          }
+        }
+      }
+    } else {
+      for (const ix of instructions) {
+        const parsed = ix.parsed;
+        if (parsed?.type === "transfer" || parsed?.type === "transferChecked") {
+          const info = parsed.info ?? {};
+          if (info.destination === expectedRecipient || info.owner === expectedRecipient) {
+            if (expectedAmount !== void 0) {
+              const amount = BigInt(
+                info.amount ?? info.tokenAmount?.amount ?? 0
+              );
+              if (amount === expectedAmount) matched = true;
+            } else {
+              matched = true;
+            }
+          }
+        }
+      }
+    }
+    if (!matched) {
+      return { status: "found", verified: false, signature, reason: "wrong_recipient_or_amount" };
+    }
+    return {
+      status: confStatus,
+      verified: true,
+      signature
+    };
+  } catch {
+    return { status: "error", verified: false, signature, reason: "rpc_failure" };
+  }
+}
+
+export { createSolanaPayReference, findTransactionSignaturesByReference, verifySolanaPayPayment };

package/dist/solana-pay-status.d.ts

@@ -0,0 +1,5 @@
+type SolanaPayPaymentStatus = "pending" | "found" | "confirmed" | "finalized" | "expired" | "error";
+declare function getSolanaPayPaymentStatus(rpc: unknown, reference: string): Promise<SolanaPayPaymentStatus>;
+
+export { getSolanaPayPaymentStatus };
+export type { SolanaPayPaymentStatus };

package/dist/solana-pay-status.mjs

@@ -0,0 +1,13 @@
+import { findTransactionSignaturesByReference } from './solana-pay-confirmation.mjs';
+
+async function getSolanaPayPaymentStatus(rpc, reference) {
+  try {
+    const sigs = await findTransactionSignaturesByReference(rpc, reference);
+    if (!sigs || Array.isArray(sigs) && sigs.length === 0) return "pending";
+    return "found";
+  } catch {
+    return "error";
+  }
+}
+
+export { getSolanaPayPaymentStatus };

package/dist/solana-pay.d.ts

@@ -0,0 +1,140 @@
+import * as _solana_kit from '@solana/kit';
+import { Address } from '@solana/kit';
+
+declare const SOLANA_PROTOCOL = "solana:";
+declare const HTTPS_PROTOCOL = "https:";
+declare const MEMO_PROGRAM_ID: _solana_kit.Address<"MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr">;
+declare const TOKEN_PROGRAM_ID: _solana_kit.Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+declare const SOL_DECIMALS = 9;
+declare const TEN = 10n;
+
+type Recipient = Address;
+type Amount = bigint;
+type SPLToken = Address;
+type Reference = Address;
+type References = Reference | Reference[];
+type Label = string;
+type Message = string;
+type Memo = string;
+type Link = URL;
+
+declare class CreateTransferError extends Error {
+    name: string;
+}
+
+/**
+ * Fields of a Solana Pay transfer request URL.
+ */
+interface TransferRequestURLFields {
+    /** `recipient` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#recipient). */
+    recipient: Recipient;
+    /** `amount` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#amount). */
+    amount?: Amount;
+    /** `spl-token` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#spl-token). */
+    splToken?: SPLToken;
+    /** `reference` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#reference). */
+    reference?: References;
+    /** `label` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#label). */
+    label?: Label;
+    /** `message` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#message). */
+    message?: Message;
+    /** `memo` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#memo). */
+    memo?: Memo;
+}
+/**
+ * Fields of a Solana Pay transaction request URL.
+ */
+interface TransactionRequestURLFields {
+    /** `link` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#link). */
+    link: Link;
+    /** `label` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#label-1). */
+    label?: Label;
+    /** `message` in the [Solana Pay spec](https://github.com/solana-labs/solana-pay/blob/master/SPEC.md#message-1). */
+    message?: Message;
+}
+/**
+ * Encode a Solana Pay transfer or transaction request URL.
+ */
+declare function encodeURL(fields: TransferRequestURLFields | TransactionRequestURLFields): URL;
+/**
+ * Encode a Solana Pay transfer request URL.
+ */
+declare function encodeTransferRequestURL({ recipient, amount, splToken, reference, label, message, memo, }: TransferRequestURLFields): URL;
+/**
+ * Encode a Solana Pay transaction request URL.
+ */
+declare function encodeTransactionRequestURL({ link, label, message, }: TransactionRequestURLFields): URL;
+
+/**
+ * Error thrown when a URL can't be parsed as a Solana Pay URL.
+ */
+declare class ParseURLError extends Error {
+    name: string;
+}
+/**
+ * Parse a Solana Pay URL.
+ *
+ * @throws {ParseURLError} when the URL is not a valid Solana Pay URL.
+ */
+declare function parseURL(url: string | URL): TransferRequestURLFields | TransactionRequestURLFields;
+
+/**
+ * A small QR renderer for Solana Pay URLs.
+ *
+ * The `qrcode` package is loaded lazily so apps that only encode/parse payment
+ * URLs never pay for the QR encoder in their initial bundle.
+ */
+interface QROptions {
+    width?: number;
+    margin?: number;
+    color?: {
+        dark?: string;
+        light?: string;
+    };
+    errorCorrectionLevel?: "L" | "M" | "Q" | "H";
+    logo?: string;
+    logoSize?: number;
+    logoBackgroundColor?: string;
+    logoMargin?: number;
+    dotStyle?: "dots" | "rounded" | "square";
+    cornerStyle?: "square" | "rounded" | "extra-rounded" | "full-rounded" | "maximum-rounded";
+}
+/**
+ * Build the default styling options for a Solana Pay QR code.
+ */
+declare function createQROptions(_url: string | URL, size?: number, background?: string, color?: string): QROptions;
+/**
+ * Render a Solana Pay URL as styled SVG.
+ */
+declare function createStyledQRCode(url: string | URL, options: QROptions): Promise<string>;
+/**
+ * Render a Solana Pay URL as an SVG string.
+ */
+declare function createQR(url: string | URL, size?: number, background?: string, color?: string): Promise<string>;
+/**
+ * Render a Solana Pay URL as a `data:` URL containing SVG markup.
+ *
+ * Percent-encoding keeps this free of `Buffer`, so it works in the browser and
+ * during SSR without the Buffer polyfill.
+ */
+declare function createQRDataURL(url: string | URL, options: QROptions): Promise<string>;
+/**
+ * Render a Solana Pay URL into an existing canvas element.
+ */
+declare function createQRCanvas(canvas: HTMLCanvasElement, url: string | URL, options: QROptions): Promise<void>;
+
+/**
+ * Safely convert a string address to an `SPLToken`.
+ */
+declare function createSPLToken(tokenAddress: string): SPLToken;
+/**
+ * Safely convert a string address to a `Recipient`.
+ */
+declare function createRecipient(recipientAddress: string): Recipient;
+/**
+ * Validate a string as a Solana address.
+ */
+declare function isValidSolanaAddress(addr: string): boolean;
+
+export { CreateTransferError, HTTPS_PROTOCOL, MEMO_PROGRAM_ID, ParseURLError, SOLANA_PROTOCOL, SOL_DECIMALS, TEN, TOKEN_PROGRAM_ID, createQR, createQRCanvas, createQRDataURL, createQROptions, createRecipient, createSPLToken, createStyledQRCode, encodeTransactionRequestURL, encodeTransferRequestURL, encodeURL, isValidSolanaAddress, parseURL };
+export type { Amount, Label, Link, Memo, Message, QROptions, Recipient, Reference, References, SPLToken, TransactionRequestURLFields, TransferRequestURLFields };

package/dist/solana-pay.mjs

@@ -0,0 +1 @@
+export { C as CreateTransferError, H as HTTPS_PROTOCOL, M as MEMO_PROGRAM_ID, P as ParseURLError, S as SOLANA_PROTOCOL, a as SOL_DECIMALS, T as TEN, b as TOKEN_PROGRAM_ID, c as createQR, d as createQRCanvas, e as createQRDataURL, f as createQROptions, g as createRecipient, h as createSPLToken, i as createStyledQRCode, j as encodeTransactionRequestURL, k as encodeTransferRequestURL, l as encodeURL, m as isValidSolanaAddress, p as parseURL } from './shared/core.CQFtdLrA.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-solana/core",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Framework-agnostic primitives for Vue Solana libraries.",
   "license": "MIT",
   "keywords": [
@@ -92,6 +92,18 @@
     "./token-accounts": {
       "types": "./dist/token-accounts.d.ts",
       "import": "./dist/token-accounts.mjs"
+    },
+    "./solana-pay": {
+      "types": "./dist/solana-pay.d.ts",
+      "import": "./dist/solana-pay.mjs"
+    },
+    "./solana-pay-confirmation": {
+      "types": "./dist/solana-pay-confirmation.d.ts",
+      "import": "./dist/solana-pay-confirmation.mjs"
+    },
+    "./solana-pay-status": {
+      "types": "./dist/solana-pay-status.d.ts",
+      "import": "./dist/solana-pay-status.mjs"
     }
   },
   "files": [
@@ -110,9 +122,11 @@
     "@wallet-standard/app": "^1.1.1",
     "@wallet-standard/base": "^1.1.1",
     "@wallet-standard/features": "^1.1.1",
+    "qrcode": "^1.5.4",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
+    "@types/qrcode": "^1.5.5",
     "typescript": "^5.8.3",
     "unbuild": "^3.5.0"
   },