Send a transaction

sendTransaction: (input: {
  transaction: SupportedSolanaTransaction;
  connection: Connection;
  uiOptions?: SendTransactionModalUIOptions;
  transactionOptions?: SendTransactionOptions;
  fundWalletConfig?: SolanaFundingConfig;
  address?: string;
}) => Promise<SolanaTransactionReceipt>

import {useSendTransaction} from '@privy-io/react-auth/solana';
import {Connection, Transaction, VersionedTransaction} from '@solana/web3.js';

// Inside your component
const { sendTransaction } = useSendTransaction();

// Configure your connection to point to the correct Solana network
const connection = new Connection('https://api.mainnet-beta.solana.com');

// Create your transaction (either legacy Transaction or VersionedTransaction)
const transaction = new Transaction(); // or new VersionedTransaction()
// Add your instructions to the transaction...

// Send the transaction
const receipt = await sendTransaction({
    transaction: transaction,
    connection: connection
});

console.log("Transaction sent with signature:", receipt.signature);

request: (request: {
  method: 'signAndSendTransaction',
  params: {
    transaction: Transaction | VersionedTransaction,
    connection: Connection
  }
}) => Promise<{ signature: string }>

import {Connection} from '@solana/web3.js';
import {useEmbeddedSolanaWallet} from '@privy-io/expo';

const { wallets } = useEmbeddedSolanaWallet();
const wallet = wallets[0];

// Get the provider
const provider = await wallet.getProvider();

// Create a connection to the Solana network
const connection = new Connection('insert-your-rpc-url-here');

// Create your transaction (either legacy Transaction or VersionedTransaction)
// transaction = ...

// Send the transaction
const { signature } = await provider.request({
  method: 'signAndSendTransaction',
  params: {
    transaction: transaction,
    connection: connection,
  },
});

console.log("Transaction sent with signature:", signature);

public protocol EmbeddedSolanaWalletProvider {
    func signMessage(message: String) async throws -> String
}

import SolanaSwift

// Get the provider for wallet (assumes wallet is already obtained)
let provider = wallet.provider

// Create a Solana RPC client
let solana = JSONRPCAPIClient(endpoint: URL(string: "https://api.mainnet-beta.solana.com")!)

// Build the transaction using your preferred method
let latestBlockhash = try await solana.getLatestBlockhash()
let walletPK = try PublicKey(string: wallet.address)
var tx = Transaction()
tx.instructions.append(
    SystemProgram.transferInstruction(
        from: walletPK,
        to: try PublicKey(string: "9NvE68JVWHHHGLp5NNELtM5fiBw6SXHrzqQJjUqaykC1"),
        lamports: 100000000000000
    )
)
tx.recentBlockhash = latestBlockhash
tx.feePayer = walletPK

// Serialize the transaction for signing as base64
let message = try tx.compileMessage().serialize().base64EncodedString()

// Sign using the Privy Embedded Wallet
let signature = try await provider.signMessage(message: message)

// Add the signature back to the transaction
try tx.addSignature(signature: Data(base64Encoded: signature)!, publicKey: walletPK)

// Send the transaction via a JSON-RPC call
let txHash = try await solana.sendTransaction(transaction: tx.serialize().base64EncodedString())

print("Transaction sent with hash: \(txHash)")

public suspend fun signMessage(message: String): Result<String>

// Retrieve user's Solana wallet (assumes wallet is already obtained)
val solanaWallet = user.embeddedSolanaWallets.first()

// Create a Solana RPC client
val connection = Connection("https://api.mainnet-beta.solana.com")

// Build the transaction
val walletPublicKey = PublicKey(solanaWallet.address)
val instruction = SystemProgram.transfer(
    fromPubkey = walletPublicKey,
    toPubkey = PublicKey(recipientAddress),
    lamports = amount
)

// Get recent blockhash
val recentBlockhash = connection.getLatestBlockhash()

// Create transaction
val transaction = Transaction()
transaction.add(instruction)
transaction.recentBlockhash = recentBlockhash
transaction.feePayer = walletPublicKey

// Serialize transaction to base64
val serializedTransaction = transaction.serializeMessage().base64()

// Sign the transaction message
val result = solanaWallet.provider.signMessage(serializedTransaction)

when (result) {
    is Result.Success -> {
        // Add signature to transaction
        val signature = result.data
        transaction.addSignature(walletPublicKey, Base64.decode(signature))

        // Send the transaction
        val txHash = connection.sendRawTransaction(transaction.serialize())
        // Handle successful transaction
    }
    is Result.Failure -> {
        // Handle error
    }
}

Future<Result<String>> signMessage(String message);

// Retrieve the user's Solana wallet (assumes wallet is already obtained)
final solanaWallet = user.embeddedSolanaWallets.first;

// Create a Solana RPC client
final connection = Connection('https://api.mainnet-beta.solana.com');

// Build the transaction
final walletPublicKey = PublicKey(solanaWallet.address);
final instruction = SystemProgram.transfer(
    fromPubkey: walletPublicKey,
    toPubkey: PublicKey(recipientAddress),
    lamports: amount
);

// Get recent blockhash
final recentBlockhash = await connection.getLatestBlockhash();

// Create transaction
final transaction = Transaction();
transaction.add(instruction);
transaction.recentBlockhash = recentBlockhash;
transaction.feePayer = walletPublicKey;

// Serialize transaction to base64
final serializedTransaction = base64Encode(transaction.serializeMessage());

// Sign the transaction message
final result = await solanaWallet.provider.signMessage(serializedTransaction);

// Handle the result
result.when(
    success: (signature) {
        // Add signature to transaction
        transaction.addSignature(walletPublicKey, base64Decode(signature));

        // Send the transaction
        connection.sendRawTransaction(transaction.serialize())
          .then((txHash) {
            print('Transaction sent with hash: $txHash');
          });
    },
    failure: (error) {
        print('Failed to sign transaction: $error');
    },
);

signAndSendTransaction: (input: SolanaSignAndSendTransactionInputType) => Promise<SolanaSignAndSendTransactionResponseType>

import {
  PublicKey,
  SystemProgram,
  VersionedTransaction,
  TransactionMessage,
} from '@solana/web3.js';

const walletPublicKey = new PublicKey(wallet.address);
const instruction = SystemProgram.transfer({
  fromPubkey: walletPublicKey,
  toPubkey: new PublicKey(recipientAddress),
  lamports: amount,
});

const message = new TransactionMessage({
  payerKey: walletPublicKey,
  instructions: [instruction],
  recentBlockhash,
});

const transaction = new VersionedTransaction(message.compileToV0Message());

const {hash} = await privy.walletApi.solana.signAndSendTransaction({
  walletId: 'insert-wallet-id',
  caip2: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1', // Mainnet
  transaction: transaction,
});

https://api.privy.io/v1/wallets/<wallet_id>/rpc

$ curl --request POST https://api.privy.io/v1/wallets/<wallet_id>/rpc \
-u "<your-privy-app-id>:<your-privy-app-secret>" \
-H "privy-app-id: <your-privy-app-id>" \
-H "privy-authorization-signature: <authorization-signature-for-request>" \
-H 'Content-Type: application/json' \
-d '{
    "method": "signAndSendTransaction",
    "caip2": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
    "params": {
        "transaction": "insert-base-64-encoded-serialized-transaction",
        "encoding": "base64"
    }
}'

{
    "method": "signAndSendTransaction",
    "data": {
        "hash": "insert-transaction-hash",
        "caip2": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
    }
}