@vue-solana/core 4.0.0 → 4.1.1

package/README.md

@@ -12,7 +12,9 @@ Framework-agnostic Solana primitives for Vue Solana libraries and apps that want
 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.
@@ -24,28 +26,45 @@ Use this package directly when you want Kit RPC client helpers, shared wallet ty
 Official Solana docs:
 
 - [Solana Documentation](https://solana.com/docs)
+
 - [Solana RPC Methods](https://solana.com/docs/rpc)
+
 - [Solana Clusters](https://solana.com/docs/references/clusters)
 
 Full Vue Solana docs:
 
 - [`@vue-solana/core`](https://vue-solana-docs.vercel.app/packages/core)
+
 - [Live demo](https://vue-solana-docs.vercel.app/demo)
+
 - [Getting Started](https://vue-solana-docs.vercel.app/getting-started)
+
 - [Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
+
 - [Troubleshooting](https://vue-solana-docs.vercel.app/troubleshooting)
 
 ## Features
 
 - Cluster-aware RPC helpers with HTTP and WebSocket endpoint defaults.
+
 - A Kit `client` with lazy `rpc` and `rpcSubscriptions` plus the official transaction planner and RPC plan-sending executor through `createSolanaClient()` / `createSolanaContext()`.
+
 - Shared `SolanaConfig`, `SolanaContext`, and `SolanaWallet` types for framework integrations.
+
 - Wallet capability assertions for connection, message signing, and transaction signing flows.
+
 - Browser Wallet Standard adaptation primitives.
+
 - Android Mobile Wallet Adapter registration helpers.
+
 - 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, QR rendering, and reference-based settlement confirmation, implemented directly on Kit.
+
 - A framework-agnostic action state machine (`createSolanaActionStore`) for async Solana work with per-attempt `AbortSignal` handling.
 
 ## Compatibility
@@ -153,54 +172,85 @@ https://faucet.solana.com
 Direct subpaths:
 
 - `@vue-solana/core/action`
+
 - `@vue-solana/core/types`
+
 - `@vue-solana/core/address`
+
 - `@vue-solana/core/buffer-polyfill`
+
 - `@vue-solana/core/clusters`
+
 - `@vue-solana/core/errors`
+
 - `@vue-solana/core/ios-wallet`
+
 - `@vue-solana/core/kit`
+
 - `@vue-solana/core/mobile-wallet`
+
 - `@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(url, options)` and `createQRCanvas(canvas, url, options)` cover the other render targets. The `qrcode` encoder loads lazily.                                |
+| `encodeTransferRequestURL(fields)` / `encodeTransactionRequestURL(fields)`             | Builds one request kind explicitly; `encodeURL()` picks the same one from the fields you pass.                                                                                                                          |
+| `createRecipient(address)` / `createSPLToken(address)` / `isValidSolanaAddress(value)` | Address helpers for request fields and scanned-URL validation.                                                                                                                                                          |
+| `createSolanaPayReference()`                                                           | Generates a reference `Address` that `getSignaturesForAddress()` can look up later.                                                                                                                                     |
+| `verifySolanaPayPayment(rpc, options)`                                                 | Polls the reference and verifies the settled transaction pays `expectedRecipient`, plus `expectedAmount` and `expectedTokenMint` when given.                                                                            |
+| `getSolanaPayPaymentStatus(rpc, reference)`                                            | Non-verifying read: `pending` before a signature exists, `found` after one does, `error` when the RPC call fails.                                                                                                       |
+| `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.                                              |
+| `registerSolanaMobileWallet(config?)`                                                  | Registers an Android Mobile Wallet Adapter wallet through `@solana-mobile/wallet-standard-mobile`.                                                                                                                      |
+| `isSolanaMobileWalletSupported()`                                                      | Android-support gate used to decide whether to lazy-load the MWA module.                                                                                                                                                |
+| `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. 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.                                                                                                                                                      |
+| `normalizeSolanaError(error)`                                                          | Normalizes an unknown error into a `SolanaError`.                                                                                                                                                                       |
+| `isSolanaActionAborted(error)`                                                         | Detects abort errors from superseded action dispatches.                                                                                                                                                                 |
+
+The Solana Pay request helpers live in `@vue-solana/core/solana-pay`; `createSolanaPayReference()` and `verifySolanaPayPayment()` live in `@vue-solana/core/solana-pay-confirmation`, and `getSolanaPayPaymentStatus()` lives in `@vue-solana/core/solana-pay-status`.
 
 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`. |
-| `isSolanaMobileWalletSupported()` | Android-support gate used to decide whether to lazy-load the MWA module. |
-| `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. 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. |
-| `normalizeSolanaError(error)` | Normalizes an unknown error into a `SolanaError`. |
-| `isSolanaActionAborted(error)` | Detects abort errors from superseded action dispatches. |
 
 ## Wallet Interface
 
@@ -226,9 +276,13 @@ The Wallet Standard adapter verifies the signature a wallet returns from `signMe
 Current wallet support:
 
 - Browser extension wallets through Wallet Standard packages.
+
 - Android native mobile wallets through `@solana-mobile/wallet-standard-mobile` on Android Chrome and Chrome PWAs.
+
 - iOS browser wallets for Phantom, Solflare, and Backpack through wallet-specific universal links.
+
 - Message signing when the active wallet exposes `signMessage`.
+
 - Manual/custom wallet objects that implement `SolanaWallet`.
 
 Planned but not supported yet:
@@ -240,7 +294,9 @@ Planned but not supported yet:
 For complete runnable Vue and Nuxt examples that use this package through the framework integrations, see:
 
 - [Live demo](https://vue-solana-docs.vercel.app/demo)
+
 - <a href="https://vue-solana-docs.vercel.app/examples/vue-vite" target="_blank" rel="noopener noreferrer"><code>examples/vue-vite</code></a>
+
 - <a href="https://vue-solana-docs.vercel.app/examples/nuxt" target="_blank" rel="noopener noreferrer"><code>examples/nuxt</code></a>
 
 ## Bundle size and lean imports
@@ -250,11 +306,17 @@ The root barrel (`@vue-solana/core`) intentionally re-exports the full `@solana/
 Size-sensitive entries can avoid pulling the whole mirror by importing the narrow subpaths instead of the root:
 
 - `@vue-solana/core/address`
+
 - `@vue-solana/core/errors`
+
 - `@vue-solana/core/timeout`
+
 - `@vue-solana/core/clusters`
+
 - `@vue-solana/core/rpc`
+
 - `@vue-solana/core/types`
+
 - `@vue-solana/core/kit` (when you explicitly want the Kit surface)
 
 Avoid importing `@vue-solana/core/ios-wallet` or `@vue-solana/core/mobile-wallet` from lean code paths: they own `tweetnacl` and the Mobile Wallet Adapter protocol graph respectively. The `@vue-solana/core/mobile-wallet-support` subpath ships only the Android-support gate used to decide whether to lazy-load the MWA module.
@@ -274,9 +336,13 @@ Docs: [Vue Solana Agent Skill](https://vue-solana-docs.vercel.app/agent-skill)
 ## Caveats
 
 - Public Solana RPC endpoints are useful for development, but production apps should use dedicated RPC infrastructure.
+
 - Use `mainnet` for Solana mainnet. This is Solana's official mainnet cluster name; the legacy `mainnet-beta` spelling is still accepted and redirects to the same endpoint.
+
 - Transactions are raw wire bytes. Build transaction messages with `@vue-solana/core/kit` (`createTransactionMessage()`, `compileTransaction()`) and serialize them before passing them to wallet flows.
+
 - v2.0.0 removed `@solana/web3-compat` and the `web3` subpaths. See the [Kit Migration guide](https://vue-solana-docs.vercel.app/guides/kit-migration) for migrating from v1.
+
 - Desktop native app wallets are planned but not implemented yet.
 
 ## Status

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