Signing the transaction

What you receive

By default the transaction is a Solana transaction v1: every account is inline (no address lookup table), and the compute-unit limit, loaded-accounts-data limit and priority fee are in the message header instead of ComputeBudget instructions. The sender is the only signer. With "txVersion": 0 it is a v0 transaction against our deposit lookup table.

Library support

Staying on v0

• Send "txVersion": 0 (a JSON number) when you create the order. Any value other than 0 or 1 returns 400 INVALID_TX_VERSION.
• The order remembers the choice. A refresh without a query rebuilds the same version.
• Orders created before v1 became the default rebuild as v1 on refresh. Pass ?txVersion=0 if you still need v0.

In a browser: Wallet Standard

Pass the raw bytes to the user's wallet and never touch a key. Check at runtime that the wallet can sign v1, and fall back to v0 if it cannot. Cloak has not confirmed which major wallets advertise v1 yet, and Ledger's Solana app did not sign v1 as of September 2026, so keep the txVersion: 0 fallback.

const bytes   = Uint8Array.from(atob(order.transaction), (c) => c.charCodeAt(0));
const feature = wallet.features["solana:signTransaction"];
if (order.transactionVersion === 1 && !feature.supportedTransactionVersions.includes(1)) {
  // This wallet cannot sign v1: have your backend refresh the order with
  // ?txVersion=0 and sign that transaction instead.
}
const [{ signedTransaction }] = await feature.signTransaction({
  account,                                // the sender's WalletAccount
  chain: "solana:mainnet",
  transaction: bytes,
});
// Submit signedTransaction exactly as returned.
const signature = await connection.sendRawTransaction(signedTransaction);

Sign the bytes, submit

These examples are for a server-side or custodial signer. Every recipe works for both v1 and v0.

# Signing is not possible from a shell: a private key must never transit
# a command line or environment variable in production.
#
# Pass order.transaction to your wallet layer instead:
#
#   1. base64-decode it (v1 unless order.transactionVersion is 0)
#   2. sign the raw bytes with the sender's key: a v1-capable signer, or
#      create the order with "txVersion": 0 if yours only handles v0
#   3. submit the exact signed bytes to your RPC:
#        sendTransaction(base64, { "encoding": "base64" })
#
# Every other tab shows that in a real language.

SDK-specific signing behavior

Some SDKs do not attach a signature when you modify a deserialized transaction directly. Follow the language example above: Python rebuilds from unsigned.message, and Rust uses try_new. Always submit the exact signed bytes, base64-encoded, rather than a re-parsed transaction object.

After submission

• Confirm the transaction, then optionally call POST /deposit so Cloak can process it sooner.
• If submission fails on an expired blockhash, call refresh and sign again. This cannot double-spend. Check transactionVersion on the refreshed transaction too.
• Then poll status until final.