Pay Offramp Orders on Solana

Sign and broadcast the deposit transaction for an existing Solana offramp order.

Every offramp order returns a prepared deposit transaction that the payer must sign and broadcast before the order leaves the payment phase. On Solana, that transaction has its own format and a blockhash that can expire, so it can’t be sent with the EVM steps in the quickstart. This guide shows how to sign and broadcast it — from a Crossmint wallet or your own Solana keypair — so Crossmint matches the deposit to the order and the payout can proceed.

For the complete offramp lifecycle, see the REST API Quickstart.

Prerequisites

You need:

• Offramp order: created with payment.method: "solana" via Create Order.
• Payer wallet: a Crossmint wallet on chain: "solana" with a configured signer, or an external Solana wallet whose public key matches the order’s payment.payerAddress.
• Funds: enough USDC to pay the order and enough SOL to cover the network fee.

Pay the Order

Crossmint wallet

The prepared blockhash may expire before the user approves the transaction. To avoid signing an expired transaction, fetch a current blockhash from your server and rebuild the transaction before sending it to the wallet.

import { useWallet, SolanaWallet } from "@crossmint/client-sdk-react-ui";
import { Transaction } from "@solana/web3.js";
import bs58 from "bs58";

type OfframpOrder = {
    orderId: string;
    payment: {
        preparation: {
            serializedTransaction: string;
        };
    };
};

export function PayOfframpOrder({ order }: { order: OfframpOrder }) {
    const { wallet } = useWallet();

    async function pay() {
        if (wallet == null) {
            throw new Error("Wallet not ready");
        }

        const prepared = Transaction.from(
            bs58.decode(order.payment.preparation.serializedTransaction),
        );

        const blockhash = await fetch("/api/solana-blockhash").then(
            (response) => response.text(),
        );

        const transaction = new Transaction({
            feePayer: prepared.feePayer,
            recentBlockhash: blockhash,
        });

        transaction.add(...prepared.instructions);

        const { hash } = await SolanaWallet.from(wallet).sendTransaction({
            serializedTransaction: bs58.encode(
                transaction.serialize({
                    requireAllSignatures: false,
                    verifySignatures: false,
                }),
            ),
        });

        console.log(`https://explorer.solana.com/tx/${hash}`, order.orderId);
    }

    return <button onClick={pay}>Cash out</button>;
}

This copies every instruction from the prepared transaction while replacing only its blockhash.

See Custom Solana Transactions for wallet and signer setup.

External wallet

Use this flow when you control the payer wallet’s keypair. The example verifies the payer, replaces the expiring blockhash, signs the transaction, and broadcasts it through your Solana RPC endpoint. order is the response from Create Order or Get Order.

import {
    Connection,
    Keypair,
    SendTransactionError,
    Transaction,
} from "@solana/web3.js";
import bs58 from "bs58";

const connection = new Connection(
    process.env.SOLANA_RPC_URL!,
    "confirmed",
);

const payer = Keypair.fromSecretKey(
    bs58.decode(process.env.SOLANA_PRIVATE_KEY!),
);

type OfframpOrder = {
    orderId: string;
    payment: {
        preparation: {
            serializedTransaction: string;
        };
    };
};

export async function payOfframpOrder(order: OfframpOrder) {
    const prepared = Transaction.from(
        bs58.decode(order.payment.preparation.serializedTransaction),
    );

    if (prepared.feePayer?.equals(payer.publicKey) !== true) {
        throw new Error(
            `Order expects payer ${prepared.feePayer?.toBase58()}`,
        );
    }

    const { blockhash, lastValidBlockHeight } =
        await connection.getLatestBlockhash("confirmed");

    const transaction = new Transaction({
        feePayer: prepared.feePayer,
        recentBlockhash: blockhash,
    });

    transaction.add(...prepared.instructions);
    transaction.partialSign(payer);

    let signature: string;

    try {
        signature = await connection.sendRawTransaction(
            transaction.serialize(),
        );
    } catch (error) {
        if (error instanceof SendTransactionError) {
            console.error(await error.getLogs(connection));
        }

        throw error;
    }

    await connection.confirmTransaction(
        { signature, blockhash, lastValidBlockHeight },
        "confirmed",
    );

    console.log(
        `https://explorer.solana.com/tx/${signature}`,
        order.orderId,
    );
}

serializedTransaction is base58-encoded. If the transaction fails to send, SendTransactionError.getLogs() returns the Solana program logs.

Why the Blockhash Must Be Replaced

Solana rejects transactions after their blockhash expires. The prepared transaction’s blockhash expires roughly a minute after Crossmint builds it, well before the order’s quote.expiresAt.

For this reason, do not treat quote.expiresAt as the transaction-signing deadline. Fetch a current blockhash immediately before signing.

Replacing the blockhash does not require a new order or quote. Copy the original transaction’s fee payer and instructions into a new transaction, then sign it against the current blockhash.

Confirm the Payout

A confirmed Solana transaction proves that the USDC left the payer’s wallet. It does not prove that the fiat payout reached the recipient.

Use Get Order or subscribe to the webhooks described in Manage Orders.

Next Steps

Manage Orders

Track order phases, delivery statuses, and webhooks.

Custom Solana Transactions

Wallet and signer setup per platform.