Thirteen screens down to three: read the swap before you sign it

The news

On 16 November 2026, Ledger enabled clear signing on Solana. Instead of confirming raw transaction data, people using its hardware wallets now see in plain words what a supported app is asking them to approve. Ledger says it covers nine Solana apps and 18 of the 22 most common actions, starting with Jupiter and Kamino, and was built with the Solana Foundation and Anza. A Jupiter swap that used to take 13 hard-to-read screens on the device now takes three: what you give, what you get, and who you're dealing with.

Before this, most Solana DeFi on a Ledger needed blind signing, a setting that is off by default and that Ledger's own guide compares to signing a blank check.

I wanted to see the gap for myself, so I wrote a small script that takes a real transaction and prints both sides: what a blind signer is shown, and what a person would want to read.

The script

Node 18 or later, no packages. It talks to a Solana RPC node over plain JSON-RPC.

// read-before-sign.mjs // node read-before-sign.mjs [signature] (no signature: picks a recent Jupiter v6 swap) // SOLANA_RPC env var, default https://api.mainnet-beta.solana.com (public, rate limited) const RPC = process.env.SOLANA_RPC || 'https://api.mainnet-beta.solana.com'; const JUPITER_V6 = 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'; const KNOWN = { [JUPITER_V6]: 'Jupiter aggregator v6', ComputeBudget111111111111111111111111111111: 'Compute budget', '11111111111111111111111111111111': 'System program', TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA: 'SPL Token', TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb: 'Token-2022', ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL: 'Associated token account', }; async function rpc(method, params) { for (let i = 0; i < 5; i++) { const r = await fetch(RPC, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }), }); if (r.status === 429) { await new Promise((ok) => setTimeout(ok, 1500 * (i + 1))); continue; } const j = await r.json(); if (j.error) throw new Error(`${method}: ${j.error.message}`); return j.result; } throw new Error(`${method}: rate limited`); } const getTx = (sig, encoding) => rpc('getTransaction', [sig, { encoding, maxSupportedTransactionVersion: 1, commitment: 'confirmed' }]); // What moved for the fee payer: token balances before and after, plus native SOL. function changesFor(tx) { const owner = tx.transaction.message.accountKeys[0].pubkey; const out = []; const pre = new Map(tx.meta.preTokenBalances.filter((b) => b.owner === owner).map((b) => [b.mint, b])); const post = new Map(tx.meta.postTokenBalances.filter((b) => b.owner === owner).map((b) => [b.mint, b])); for (const mint of new Set([...pre.keys(), ...post.keys()])) { const a = Number(pre.get(mint)?.uiTokenAmount.uiAmountString ?? 0); const b = Number(post.get(mint)?.uiTokenAmount.uiAmountString ?? 0); const dp = pre.get(mint)?.uiTokenAmount.decimals ?? post.get(mint)?.uiTokenAmount.decimals ?? 9; const d = Number((b - a).toFixed(dp)); if (d !== 0) out.push({ asset: mint, delta: d }); } const lamports = tx.meta.postBalances[0] - tx.meta.preBalances[0] + tx.meta.fee; if (lamports !== 0) out.push({ asset: 'SOL (native)', delta: lamports / 1e9 }); return out; } 

The rest picks a transaction (the full file also has a small pickRecentSwap() that walks the last 25 Jupiter v6 signatures and keeps the first one where something leaves the signer's wallet and something arrives), fetches it twice, once as base64 and once as jsonParsed, and prints both views:

const { createHash } = await import('node:crypto'); const short = (s) => (s.length > 12 ? `${s.slice(0, 4)}…${s.slice(-4)}` : s); const parsed = await getTx(sig, 'jsonParsed'); const raw = await getTx(sig, 'base64'); const bytes = Buffer.from(raw.transaction[0], 'base64'); console.log('Blind signing shows something like this:'); console.log(' ' + createHash('sha256').update(bytes).digest('hex').toUpperCase().match(/.{1,16}/g).join(' ')); console.log('What you would want to read instead:'); for (const c of changesFor(parsed)) { console.log(` ${c.delta < 0 ? 'You send ' : 'You receive'} ${Math.abs(c.delta)} ${c.asset}`); } console.log(` Network fee ${parsed.meta.fee / 1e9} SOL`); for (const p of new Set(parsed.transaction.message.instructions.map((i) => i.programId))) { console.log(` Calls ${KNOWN[p] || 'unknown program'} ${short(p)}`); } 

What it printed

One run against mainnet on 17 November 2026, around 02:30 UTC:

Transaction 2CDu…9sfc (v1, 1475 bytes) Blind signing shows something like this: D28D2DE32DA68B0D 8DA62286A5B61407 DA60CD967EDF2B0E B4AA52AB0C500D67 810100120f0000008d4ff3666cfff186 0a12efcf5b2143fdc6c997591246d637 de07e4057a17d94604254f6e557c2757 … What you would want to read instead: You receive 1044.475045 mint 2Nbz…pump You send 0.00014947 SOL (native) Network fee 0.000007091 SOL Programs it calls: System program 1111…1111 Associated token account ATok…8knL unknown program 6Vo3…uTAB 

Two things stood out.

The top half is all a device without a decoder can honestly show. Nothing in those bytes tells a person which token leaves, how much arrives, or where it goes.

The bottom half came from the node, after the fact, with full knowledge of every account. Even so, the top-level program in this transaction wasn't one my little table knew, so it printed unknown program. That's the exact problem clear signing solves: someone has to describe what a program's instructions mean before a wallet can show them in words. Ledger's documentation says that outside its own wallet app, this depends on the app's developer and on how you connect.

The run also caught a new detail: the transaction came back as version 1, and the RPC refused it until I raised maxSupportedTransactionVersion from 0 to 1. If your tooling still asks for 0, it will start failing on these.

Limits of this script

  • It reads a transaction that already landed. A wallet has to do this before signing, from the unsigned message, which is much harder: it needs simulation or per-program metadata.
  • It only counts balances owned by the fee payer. Swaps routed through other accounts, or wrapped SOL that gets closed in the same transaction, can look odd.
  • Results change every run, because it picks whatever Jupiter swap is recent.

The takeaway for builders

If you ship a Solana app, publish what your instructions mean so wallets can show them, and design flows where the three numbers that matter (what leaves, what arrives, where it goes) are visible before anyone signs. If your users still have to blind sign, assume some of them are signing things they would have rejected.

Sources: Decrypt, "Ledger Brings Clear Signing to Solana, Ending 'Blind' Signing for Jupiter Swaps" (16 Nov 2026); Ledger Academy, "What is Clear Signing?"; Solana JSON-RPC getTransaction docs.