What is Solana Pay and How to Use It

Overview

Solana Pay is a fast, secure, and user-friendly payment protocol built on the Solana blockchain. It enables direct peer-to-peer transactions with near-instant finality and negligible fees. This guide explains its core functionality and provides a practical walkthrough for developers.

Understanding Solana Pay

Solana Pay is a decentralized payment framework designed for digital commerce. It allows merchants to accept payments directly in SOL or any SPL token without intermediaries. By leveraging the Solana network's high throughput and low costs, it eliminates traditional payment processing delays and fees.

How Solana Pay Works

The protocol uses a standardized URL scheme to create payment requests. These requests can be shared via QR codes, buttons, or deep links. Here’s a simplified breakdown of the workflow:

Order Creation: A customer selects a product or service on a merchant’s platform.
Payment Link Generation: The merchant's system generates a unique Solana Pay URL containing transaction details.
Transaction Approval: The customer's wallet app parses the URL, displays the request, and prompts the user to approve the payment.
Validation: The merchant's backend verifies the on-chain transaction to confirm receipt of the correct amount.

This process ensures payments are secure, transparent, and efficient.

Building a Basic Solana Pay Application

This section guides you through creating a simple demo application to simulate a payment flow.

Prerequisites

Before you start, ensure you have the following:

Node.js (version 16.15 or higher) installed on your system.
A basic understanding of TypeScript.
A Solana wallet with Devnet SOL for testing purposes.

Setting Up the Development Environment

Begin by initializing a new project and installing the necessary dependencies.

# Create a new project directory
mkdir solana-pay-demo
cd solana-pay-demo

# Initialize a new Node.js project
npm init -y

# Install required dependencies
npm install @solana/web3.js@1 @solana/pay bignumber.js

Create a tsconfig.json file to enable JSON imports and TypeScript compilation.

Establishing a Blockchain Connection

To interact with the Solana blockchain, you need a reliable RPC endpoint. While public nodes are available, a dedicated service provides faster response times and greater reliability for development.

👉 Get a dedicated Solana RPC endpoint here

After obtaining your endpoint, you can establish a connection in your code.

Core Application Code

Create an index.ts file and import the necessary libraries.

import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js';
import { encodeURL, validateTransfer, parseURL, findReference } from '@solana/pay';
import BigNumber from 'bignumber.js';

Define the constants for your application, including your recipient wallet address, the RPC endpoint, and transaction details.

// Application Constants
const recipient = new PublicKey('Your_Wallet_Address_Here');
const connection = new Connection('Your_QuickNode_Endpoint_Here', 'confirmed');
const amount = new BigNumber(0.1); // Payment amount in SOL
const reference = new Keypair().publicKey; // Unique reference for the transaction
const label = 'My Demo Store'; // Label shown in the wallet
const message = 'Thank you for your order!'; // Message for the customer
const memo = 'On-chain order memo'; // Public memo recorded on-chain

Generating a Payment Request URL

The first step is to create a function that generates the payment request URL.

async function generatePaymentUrl(recipient: PublicKey, amount: BigNumber, reference: PublicKey, label: string, message: string, memo: string) {
    const url = encodeURL({ recipient, amount, reference, label, message, memo });
    return url;
}

This URL encodes all payment details and can be presented to the user as a QR code or clickable link.

Processing the Payment

The next function simulates the customer's wallet processing the payment request and sending the transaction.

async function processPayment(url: URL, payer: Keypair) {
    const { recipient, amount, reference, memo } = parseURL(url);
    if (!recipient || !amount || !reference) throw new Error('Invalid payment link');

    // Build the transaction
    const transaction = new Transaction();

    // Add a memo instruction if one exists
    if (memo) {
        transaction.add(new TransactionInstruction({
            programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
            keys: [],
            data: Buffer.from(memo, 'utf8'),
        }));
    }

    // Create the transfer instruction
    const transferInstruction = SystemProgram.transfer({
        fromPubkey: payer.publicKey,
        toPubkey: recipient,
        lamports: amount.multipliedBy(LAMPORTS_PER_SOL).integerValue(BigNumber.ROUND_FLOOR).toNumber()
    });

    // Add the reference to the instruction
    transferInstruction.keys.push({ pubkey: reference, isWritable: false, isSigner: false });

    // Add the transfer instruction to the transaction
    transaction.add(transferInstruction);

    // Send the transaction to the network
    const signature = await sendAndConfirmTransaction(connection, transaction, [payer]);
    console.log(`Transaction confirmed: https://explorer.solana.com/tx/${signature}?cluster=devnet`);
    return signature;
}

Verifying the Transaction

After the payment is sent, the merchant must verify it on-chain.

async function verifyPayment(recipient: PublicKey, amount: BigNumber, reference: PublicKey, memo: string) {
    // Find the transaction signature from the reference key
    const signatureInfo = await findReference(connection, reference);

    // Validate the transfer details
    const validationResponse = await validateTransfer(
        connection,
        signatureInfo.signature,
        { recipient, amount, reference, memo, splToken: undefined },
        { commitment: 'confirmed' }
    );

    if (validationResponse.meta?.err) {
        throw new Error('Transaction validation failed');
    }
    return validationResponse;
}

Executing the Full Payment Flow

Finally, orchestrate the complete flow in an asynchronous function.

(async () => {
    try {
        // Generate keypair for the customer (for demo purposes)
        const customer = Keypair.generate();

        console.log('Starting Solana Pay demo...');
        const paymentUrl = await generatePaymentUrl(recipient, amount, reference, label, message, memo);
        const txSignature = await processPayment(paymentUrl, customer);
        const verification = await verifyPayment(recipient, amount, reference, memo);

        console.log('🎉 Payment successfully verified!');
    } catch (error) {
        console.error('Error:', error);
    }
})();

Frequently Asked Questions

What are the main benefits of using Solana Pay?
Solana Pay offers instant settlement, dramatically lower fees compared to traditional payment systems, and direct peer-to-peer transactions without intermediaries. It also supports a wide range of SPL tokens, not just SOL.

Is Solana Pay suitable for large-scale e-commerce?
Yes, its scalability and low cost make it an excellent choice for e-commerce. However, integration requires technical knowledge and a user base comfortable with cryptocurrency wallets.

How do I start accepting payments with Solana Pay?
You need a Solana wallet to receive funds and a backend service to generate payment requests and validate transactions on the blockchain. For a production environment, using a reliable RPC provider is essential for performance.
👉 Explore reliable node services for your project

Can I invoice someone using Solana Pay?
Absolutely. You can generate a payment request URL with a specific amount and send it to a customer via email, message, or as a QR code. They can then pay it instantly from their compatible wallet.

What happens if a transaction fails or is interrupted?
If a transaction fails on-chain, no funds are transferred. The customer would need to approve the transaction again. Your system should have logic to handle pending or failed payments and update order status accordingly.

Are Solana Pay transactions reversible?
No, like most blockchain transactions, once confirmed, they are immutable and cannot be reversed. This emphasizes the need for proper validation before confirming a payment on the merchant's side.

Conclusion

Solana Pay provides a powerful toolkit for integrating blockchain-based payments into applications. Its protocol handles the complexities of transaction generation and validation, allowing developers to focus on creating seamless user experiences. By following this guide, you've learned the core concepts and built a fundamental understanding of how to implement it.

For real-world applications, remember to implement robust error handling, secure key management, and a user-friendly interface for presenting payment requests.