SVM Gas Sponsorship

Sponsor Solana transaction fees for your users with Dynamic’s built-in gas sponsorship feature.

SVM Gas Sponsorship is an enterprise-only feature. Contact us to learn more about upgrading your plan.

On Solana, every transaction needs a small amount of SOL to pay the network fee. Gas sponsorship lets your app cover that fee instead, so users can transact without ever holding any SOL. This is one of the most common ways to remove friction for people new to crypto.

Dynamic has gas sponsorship built in. For the basic case you don’t need to change any code — flip a switch in the dashboard and your existing Solana transactions get sponsored automatically.

SVM Gas Sponsorship works only with V3 MPC embedded wallets (the wallets Dynamic creates for your users). It does not work with external wallets like Phantom.

Quick start

1. Turn on gas sponsorship in the dashboard

   1. Go to the Dynamic Dashboard
   2. Navigate to Settings → Embedded Wallets
   3. Make sure Solana (SOL) is enabled in your chain configurations
   4. Toggle on SVM Gas Sponsorship
2. Send a transaction as usual

   Once sponsorship is on, the signAndSendTransaction you already use sponsors embedded-wallet transactions automatically. No code changes required.

   import { signAndSendTransaction } from '@dynamic-labs-sdk/solana';
   
   const sendTx = async (walletAccount, transaction) => {
     // Gas is sponsored automatically when the project setting is on
     // and the wallet supports it.
     const { signature } = await signAndSendTransaction({
       transaction,
       walletAccount,
     });
   
     console.log('Transaction sent:', signature);
   };
   

If you’re sponsoring because your users hold no SOL at all, use signAndSendSponsoredTransaction instead. It guarantees the transaction is sponsored and throws if sponsorship isn’t available — rather than silently falling back to a regular (unsponsored) transaction that a user with no SOL couldn’t pay for. This is the safest choice for most “the user has an empty wallet” flows.

import { signAndSendSponsoredTransaction } from '@dynamic-labs-sdk/solana';

const { signature } = await signAndSendSponsoredTransaction({
  transaction,
  walletAccount,
});

React example

In React, use useGetWalletAccounts to get the user’s embedded wallet, then call signAndSendSponsoredTransaction from a button handler. The try/catch shows the user a friendly message if sponsorship fails (see Error handling).

import { signAndSendSponsoredTransaction, isSolanaWalletAccount, SponsorTransactionError } from '@dynamic-labs-sdk/solana';
import { useGetWalletAccounts } from '@dynamic-labs-sdk/react-hooks';
import { useState } from 'react';
import { Transaction, SystemProgram, PublicKey } from '@solana/web3.js';

function SponsoredSendButton({ recipientAddress }) {
  const { data: walletAccounts = [] } = useGetWalletAccounts();
  const walletAccount = walletAccounts.find(isSolanaWalletAccount);
  const [signature, setSignature] = useState('');
  const [error, setError] = useState('');

  const handleSend = async () => {
    if (!walletAccount) return;
    setError('');
    try {
      const transaction = new Transaction().add(
        SystemProgram.transfer({
          fromPubkey: new PublicKey(walletAccount.address),
          toPubkey: new PublicKey(recipientAddress),
          lamports: 1_000_000,
        }),
      );
      const { signature } = await signAndSendSponsoredTransaction({ transaction, walletAccount });
      setSignature(signature);
    } catch (err) {
      if (err instanceof SponsorTransactionError) {
        setError('Gas sponsorship failed');
      }
    }
  };

  return (
    <div>
      <button onClick={handleSend} disabled={!walletAccount}>Send (Sponsored)</button>
      {signature && <p>Signature: {signature.slice(0, 20)}...</p>}
      {error && <p style={{ color: 'red' }}>{error}</p>}
    </div>
  );
}

Error handling

When you require sponsorship with signAndSendSponsoredTransaction and it can’t go through, it throws a SponsorTransactionError. Wrap the call in a try/catch so you can show the user a message and decide what to do next.

import {
  signAndSendSponsoredTransaction,
  SponsorTransactionError,
} from '@dynamic-labs-sdk/solana';

const sendTransaction = async (walletAccount, transaction) => {
  try {
    const { signature } = await signAndSendSponsoredTransaction({
      transaction,
      walletAccount,
    });
    return { success: true, signature };
  } catch (error) {
    if (error instanceof SponsorTransactionError) {
      return { success: false, error: 'Gas sponsorship failed' };
    }
    return { success: false, error: error.message };
  }
};

A SponsorTransactionError is thrown when:

• The sponsorship API cannot sponsor the transaction (sponsorship not enabled, or a limit was hit)
• The wallet doesn’t support sponsored transactions (e.g. an external wallet rather than a V3 MPC embedded wallet)

---

Advanced usage

Everything below is optional. Reach for it only when you need more control than the quick start gives you.

How it works under the hood

When a transaction is sponsored, the SDK:

1. Sends the transaction to Dynamic’s backend for sponsorship
2. Replaces the fee payer with Dynamic’s sponsored account
3. Signs the sponsored transaction with the user’s wallet
4. Broadcasts to the network with skipPreflight: true by default

Automatic vs. required sponsorship

There are two ways to send a sponsored transaction, and the difference matters when sponsorship might not be available:

Function	sponsorshipMode	Behavior
signAndSendTransaction	'auto' (default)	Sponsors when project settings and the wallet support it; otherwise sends a regular transaction.
signAndSendSponsoredTransaction	always required	Always requires sponsorship; throws SponsorTransactionError if it isn’t available.

Use signAndSendSponsoredTransaction whenever a failed sponsorship should stop the transaction — for example when the user has no SOL to fall back on.

Opting out per call

Pass sponsorshipMode: 'off' to skip sponsorship for a specific transaction even when the project setting is on:

const { signature } = await signAndSendTransaction({
  sponsorshipMode: 'off',
  transaction,
  walletAccount,
});

Send options

You can pass SendOptions to override defaults. Sponsored transactions use skipPreflight: true by default, but you can override this:

const { signature } = await signAndSendSponsoredTransaction({
  transaction,
  walletAccount,
  options: { skipPreflight: false },
});

Limitations

Limitation	Details
Wallet type	Embedded wallets only (V3 MPC)
Transaction size	Maximum 2KB base64-encoded
Already-signed	Transactions with signatures are not sponsored
Batching	Each transaction sponsored individually

Related Functions

• Signing and Sending Transactions
• Getting Solana Connection
• Adding Solana Extensions