Send a Versioned Solana Transaction

React

React

import { isSolanaWallet } from '@dynamic-labs/solana';
import { useDynamicContext } from '@dynamic-labs/sdk-react-core';
import { Connection, PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, VersionedTransactionResponse } from "@solana/web3.js";

const { primaryWallet } = useDynamicContext();

if(!primaryWallet || !isSolanaWallet(primaryWallet)) {
  return;
}

const connection: Connection = await primaryWallet.getConnection();

const fromKey = new PublicKey(primaryWallet.address);
const toKey = new PublicKey(address);
const amountInLamports = Number(amount) * 1000000000;

const instructions = [
  SystemProgram.transfer({
    fromPubkey: fromKey,
    lamports: amountInLamports,
    toPubkey: toKey,
  }),
];

const blockhash = await connection.getLatestBlockhash();

// create v0 compatible message
const messageV0 = new TransactionMessage({
  instructions,
  payerKey: fromKey,
  recentBlockhash: blockhash.blockhash,
}).compileToV0Message();

const transferTransaction = new VersionedTransaction(messageV0);

const signer = await primaryWallet.getSigner();

await signer
  .signAndSendTransaction(transferTransaction)
  .then((res: any) => {
    console.log(
      `Transaction successful: https://solscan.io/tx/${res.signature}?cluster=devnet`,
    );
  })
  .catch((reason: any) => {
    console.error(reason);
  });

React Native

React Native

import { dynamicClient } from '<path to client file>'
import {
  LAMPORTS_PER_SOL,
  PublicKey,
  SystemProgram,
  TransactionMessage,
  VersionedTransaction,
} from '@solana/web3.js'

const wallet = dynamicClient.wallets.primary
if (!wallet) {
  // user is not connected yet
} else {
  const connection = dynamicClient.solana.getConnection()
  const signer = dynamicClient.solana.getSigner({ wallet })

  const { blockhash } = await connection.getLatestBlockhash()
  const amountInLamports = 1 * LAMPORTS_PER_SOL
  const fromKey = new PublicKey(wallet.address)
  const toKey = new PublicKey('<destinationAddress>')

  const instructions = [
    SystemProgram.transfer({
      fromPubkey: fromKey,
      lamports: amountInLamports,
      toPubkey: toKey,
    }),
  ]

  const messageV0 = new TransactionMessage({
    instructions,
    payerKey: fromKey,
    recentBlockhash: blockhash,
  }).compileToV0Message()

  const transaction = new VersionedTransaction(messageV0)
  const { signature } = await signer.signAndSendTransaction(transaction)

  console.log('Successful transaction signature:', signature)
}

JavaScript

import { getWalletAccounts, getActiveNetworkData } from '@dynamic-labs-sdk/client';
import { getSolanaConnection, isSolanaWalletAccount, signAndSendTransaction } from '@dynamic-labs-sdk/solana';
import { LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionMessage, VersionedTransaction } from '@solana/web3.js';

async function sendVersionedSolanaTransaction({ toAddress, amountSol }) {
  // 1) Choose a connected Solana wallet account
  const walletAccounts = getWalletAccounts();
  const walletAccount = walletAccounts.find(isSolanaWalletAccount);
  if (!walletAccount) {
    throw new Error('No connected Solana wallet account found.');
  }

  // 2) Create a Connection from the active network for this wallet
  const { networkData } = await getActiveNetworkData({ walletAccount });
  const connection = getSolanaConnection({ networkData });

  // 3) Build a versioned transfer transaction
  const fromAddress = walletAccount.accountAddress;
  const fromPubkey = new PublicKey(fromAddress);
  const toPubkey = new PublicKey(toAddress);

  const lamports = Math.round(Number(amountSol) * LAMPORTS_PER_SOL);
  const instructions = [
    SystemProgram.transfer({
      fromPubkey,
      toPubkey,
      lamports,
    }),
  ];

  const { blockhash } = await connection.getLatestBlockhash();

  const messageV0 = new TransactionMessage({
    instructions,
    payerKey: fromPubkey,
    recentBlockhash: blockhash,
  }).compileToV0Message();

  const tx = new VersionedTransaction(messageV0);

  // 4) Sign and send
  const { signature } = await signAndSendTransaction({ walletAccount, transaction: tx });

  console.log('Successful transaction signature:', signature);
}

// Example:
// await sendVersionedSolanaTransaction({ toAddress: '<DESTINATION_PUBLIC_KEY>', amountSol: 0.01 });

Flutter

You need to have dynamic_sdk_solana package installed.

Future<void> _solanaDartSendTransaction({
  required String recipientAddress,
  required String amount,
}) async {
  try {
    final double? parsedAmount = double.tryParse(amount.replaceAll(',', '.'));

    if (parsedAmount == null) {
      throw Exception('Invalid amount format');
    }

    final signer = DynamicSDK.instance.solana.createSigner(
      wallet: widget.wallet,
    );

    final connection = DynamicSDK.instance.solana.createConnection();

    final address = widget.wallet.address;

    final fromPubKey = Pubkey.fromString(address);

    final toPubKey = Pubkey.fromString(recipientAddress);

    final BlockhashWithExpiryBlockHeight recentBlockhash =
        await connection.getLatestBlockhash();

    final transaction = Transaction.v0(
        payer: fromPubKey,
        recentBlockhash: recentBlockhash.blockhash,
        instructions: [
          SystemProgram.transfer(
            fromPubkey: fromPubKey,
            toPubkey: toPubKey,
            lamports: solToLamports(parsedAmount),
          ),
        ]);

    final response = await signer.signAndSendTransaction(
      transaction: transaction,
    );

    setState(() {
      _signedMessage = response;
      _exception = null;
    });
  } catch (e) {
    setState(() {
      _exception = e.toString().split('@')[0];
      _signedMessage = null;
    });
  }
}

Simulate a Transaction

Before sending a transaction, you can simulate it to preview the effects and validate that it will succeed. Transaction simulation shows all asset transfers involved in the transaction.

Transaction simulation uses the currently selected primary wallet. Make sure the user has a wallet connected before attempting to simulate a transaction.

React Native

React Native

import { dynamicClient } from '<path to client file>'
import {
  LAMPORTS_PER_SOL,
  PublicKey,
  SystemProgram,
  TransactionMessage,
  VersionedTransaction,
} from '@solana/web3.js'

const simulateSolanaVersionedTransaction = async (to: string, amountSol: number) => {
  const connection = dynamicClient.solana.getConnection()

  const { blockhash } = await connection.getLatestBlockhash()
  const amountInLamports = Math.round(amountSol * LAMPORTS_PER_SOL)
  const fromKey = new PublicKey(dynamicClient.wallets.primary.address)
  const toKey = new PublicKey(to)

  const instructions = [
    SystemProgram.transfer({
      fromPubkey: fromKey,
      lamports: amountInLamports,
      toPubkey: toKey,
    }),
  ]

  const messageV0 = new TransactionMessage({
    instructions,
    payerKey: fromKey,
    recentBlockhash: blockhash,
  }).compileToV0Message()

  const transaction = new VersionedTransaction(messageV0)

  const simulationResult = await dynamicClient.solana.simulateSVMTransaction({
    transaction,
    type: 'SignTransaction',
  })

  console.log('Simulation result:', simulationResult)
  return simulationResult
}