Sign a transaction

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

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

// Inside your component
const {signTransaction} = useSignTransaction();

// 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...

// Sign the transaction
const signedTransaction = await signTransaction({
  transaction: transaction,
  connection: connection
});

console.log('Transaction signed successfully');

signAllTransactions: (transactions: (Transaction | VersionedTransaction)[]) =>
  Promise<(Transaction | VersionedTransaction)[]>;

import {
  clusterApiUrl,
  Connection,
  PublicKey,
  getVersionedTransaction,
  getLegacyTransaction
} from '@solana/web3.js';
import {useSolanaWallets} from '@privy-io/react-auth/solana';

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

const connection = new Connection(clusterApiUrl('devnet'));
const walletPublicKey = new PublicKey(wallet.address);

const tx1 = await getVersionedTransaction({
  connection,
  from: walletPublicKey
});
const tx2 = await getLegacyTransaction({
  connection,
  from: walletPublicKey
});

const signedTxs = await wallet.signAllTransactions([tx1, tx2]);

request: (request: {
  method: 'signTransaction',
  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 = ...

// Sign the transaction
const { signature } = await provider.request({
  method: 'signTransaction',
  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)

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)

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);

signTransaction: (input: SolanaSignTransactionInputType) => Promise<SolanaSignTransactionResponseType>

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

const walletPublicKey = new PublicKey(wallet.address);
const connection = new Connection(clusterApiUrl('devnet'));
const instruction = SystemProgram.transfer({
fromPubkey: walletPublicKey,
toPubkey: new PublicKey(address),
lamports: value * LAMPORTS_PER_SOL
});

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

const message = new TransactionMessage({
payerKey: walletPublicKey,
// Replace with your desired instructions
instructions: [instruction],
recentBlockhash
});

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

// Get the signed transaction object from the response
const {signedTransaction} = await privy.walletApi.solana.signTransaction({
walletId: wallet.id,
transaction: yourSolanaTransaction
});

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": "signTransaction",
        "params": {
        "transaction": "insert-base-64-encoded-serialized-transaction",
        "encoding": "base64"
        }
    }'

{
"method": "signTransaction",
"data": {
    "signed_transaction": "base64-encoded-serialized-signed-transaction",
    "encoding": "base64"
}
}