@vue-solana/core 4.0.0-rc.1 → 4.1.0

package/README.md

@@ -7,6 +7,16 @@
 
 Framework-agnostic Solana primitives for Vue Solana libraries and apps that want shared RPC, wallet, and transaction helpers without installing a Vue plugin.
 
+## Related packages
+
+This package is part of the Vue Solana family. Choose based on your app framework:
+
+- [`@vue-solana/core`](https://www.npmjs.com/package/@vue-solana/core) — framework-agnostic Solana primitives: Kit RPC client helpers, wallet types, Android MWA registration, iOS browser wallet helpers, message signing, token account reads, and transaction helpers. **Use this directly** when you want shared RPC/wallet/transaction helpers without installing a Vue plugin (non-Vue apps, server/relayer code, or your own framework integration).
+- [`@vue-solana/vue`](https://www.npmjs.com/package/@vue-solana/vue) — Vue 3 plugin plus composables for RPC, account, balance, wallet, message signing, live data, and transactions. **Use this** in plain Vue 3 apps (Vite, etc.).
+- [`@vue-solana/nuxt`](https://www.npmjs.com/package/@vue-solana/nuxt) — Nuxt module that installs the Vue plugin and auto-imports the composables. **Use this** in Nuxt 3/4 apps.
+
+This package (`@vue-solana/core`) is the foundation the other two build on; most apps should install `@vue-solana/vue` or `@vue-solana/nuxt` rather than this package directly.
+
 Use this package directly when you want Kit RPC client helpers, shared wallet types, Android Mobile Wallet Adapter registration helpers, message signing support, token account reads, and transaction helpers without installing the Vue plugin.
 
 `@vue-solana/core` builds on `@solana/kit`. It exposes `createSolanaClient()` and re-exports all of `@solana/kit` from `@vue-solana/core/kit`. The legacy `@solana/web3-compat` surface and the `web3` subpaths were removed in v2.0.0; transactions flow through the packages as raw `Uint8Array` wire bytes.
@@ -36,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
@@ -154,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`. |
@@ -185,7 +202,7 @@ The client-sent API is the official Kit `ClientWithTransactionSending` capabilit
 | `getSolanaIosWallets(options?)` | Builds iOS browser wallet entries (Phantom, Solflare, Backpack) as universal links. |
 | `handleSolanaIosWalletCallback()` | Completes a pending iOS wallet deep-link callback after redirect. |
 | `adaptSolanaStandardWallet(wallet)` | Adapts a Solana Wallet Standard wallet into `SolanaWallet`. |
-| `disconnectSolanaStandardWallet(walletInfo)` | Disconnects a discovered Wallet Standard wallet through its own `standard:disconnect` feature, without adapting it. |
+| `disconnectSolanaStandardWallet(walletInfo)` | Disconnects a discovered Wallet Standard wallet through its own `standard:disconnect` feature, without adapting it. Resolves `false` if the wallet has no disconnect feature, and ignores failures after a 2 s timeout. |
 | `getRegisteredSolanaWallets()` | Returns the Wallet Standard wallets currently registered in the app. |
 | `withTimeout(promise, timeoutMs, options?)` | Races a promise against a timeout, with optional abort signal. |
 | `withSolanaTimeout(promise, timeoutMs, options?)` | Solana-specific timeout wrapper with abort and error-code support. |
@@ -211,7 +228,7 @@ const wallet: SolanaWallet = {
 
 Browser extension wallets discovered through the Solana Wallet Standard are adapted into `SolanaWallet`. Android Mobile Wallet Adapter is registered through `@solana-mobile/wallet-standard-mobile` and then adapted through the same Wallet Standard adapter on supported Android Chrome clients. iOS browser wallet entries for Phantom, Solflare, and Backpack are adapted through wallet-specific universal links. Wallet capability metadata exposes whether each wallet supports message signing, transaction signing, and sign-and-send flows. You can also provide a custom object that implements `SolanaWallet` for tests or custom adapters.
 
-The Wallet Standard adapter verifies the signature a wallet returns from `signMessage` / `signIn` against the account's public key before resolving, where Ed25519 (WebCrypto) is available. A signature over the wrong bytes or from a different account rejects with `INVALID_SIGNATURE`. This is a best-effort, client-side guard — it is skipped where Ed25519 is unavailable — so server-side verification remains mandatory for auth flows.
+The Wallet Standard adapter verifies the signature a wallet returns from `signMessage` / `signIn` against the account's public key before resolving, where Ed25519 (WebCrypto) is available. A signature over the wrong bytes or from a different account rejects with `INVALID_SIGNATURE`. `signIn` also binds the result to the requested account (or active account) and rejects if the account is absent from `wallet.accounts`. This is a best-effort, client-side guard — a malformed signature is rejected even if Ed25519 verification is unavailable, but full verification is skipped where Ed25519 is unavailable — so server-side verification remains mandatory for auth flows. Connecting a wallet disconnects every other discovered wallet (swept over discovery, uncached wallets disconnected via `standard:disconnect`), so only one wallet stays authorized.
 
 Current wallet support:
 

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-rc.1",
+  "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"
   },