NewsCryptoLedger's Solana Upgrade: One Unknown Step and Users Sign Blind

Ledger's Solana Upgrade: One Unknown Step and Users Sign Blind

Author: Coindoo·

Key Takeaways

  • •Ledger's clear signing engine ships with Solana app version 1.17.0 and above and applies an all-or-nothing rule: a transaction missing a signed descriptor on any single instruction triggers a blind-signing warning for the whole approval, even for long-trusted dApps.
  • •The engine condenses multi-instruction bundles—such as an eight-instruction Jupiter Perps 'open long'—into a single intent screen through four stages labeled annotate, merge, hide and render.
  • •The system rests on two draft standards, sRFC 39 and sRFC 41, which remain open GitHub discussions, and both require that merging and hiding alter only the display while the signed transaction retains the full instruction list, with an opt-in raw view available.
  • •Ledger reports offline validation of roughly 57,000 transactions across 40 programs, including Jupiter Aggregator v6, Jupiter Perps, Kamino Lending and the OKX DEX Router, while Orca Whirlpool and DFlow are listed as current limitations.
  • •Clear signing answers only whether a transaction matches the user's intended actions; outcome simulation and risk assessment belong to Ledger's separate Transaction Check feature, which its documentation currently describes for EVM transactions on Flex and Stax devices.
Ledger's Solana Upgrade: One Unknown Step and Users Sign Blind

Ledger has rolled out a clear signing engine for Solana transactions, but the feature carries a hard rule that users will feel directly: if a single instruction in a transaction lacks a signed descriptor, the device displays a blind-signing warning for the entire approval instead of a partially readable screen.

According to a November 16 technical write-up published by Ledger, the engine ships in Solana app version 1.17.0 and above and signs on a "whole transaction or nothing" basis. Before rendering anything on screen, the device checks that every instruction in the transaction carries a descriptor — a signed description of what that program instruction does and which values it moves.

The company states the practical consequence plainly: a dApp a user has trusted for years can still produce a blind-signing warning, because the warning speaks to the state of Ledger's descriptor coverage, not to the behavior of the dApp itself.

Why One Trade Is Several Instructions

A user looking at a swap interface typically thinks in two numbers — the SOL being spent and the USDC expected in return. The transaction that executes that exchange, however, usually wraps the SOL into its token form, creates a temporary token account, runs the swap and closes the account again: four instructions attached to a single decision.

Ledger's own example is larger still. An "open long" position on Jupiter Perps consists of eight raw instructions, which the engine condenses into a single "Increase Position" intent showing the collateral, side, size and worst price.

Solana's transaction documentation explains that the instructions inside a transaction are processed together: if one fails, the entire transaction fails and its state changes revert. That atomicity protects users from a bundle that stops halfway through execution. It says nothing, however, about whether the bundle matches what the user actually meant to do. A transaction can succeed exactly as written while executing a trade its owner never intended, and the signing screen is the only place where that mismatch can surface before any funds move.

What the Merged Screen Shows — and What It Hides

The engine operates in four stages that Ledger labels annotate, merge, hide and render. Each instruction is annotated with its value "ports" — the points where tokens enter and exit. When one instruction's output feeds the next instruction's input through the same account with a compatible token, the two are merged into a single intent. Scaffolding such as the creation or closing of token accounts, or a price oracle refresh, is hidden once the engine confirms the conditions for doing so are met, and some housekeeping instructions are dropped from the display entirely. What remains is rendered as intent screens showing the fields that matter.

Two draft standards sit underneath the system. sRFC 39 describes display metadata added to a program's IDL so that wallets can label accounts and format amounts. sRFC 41, opened by a Ledger engineer in May 2026, extends it with the value-flow rules that make merging possible. Both remain open GitHub discussions rather than adopted standards, and sRFC 41 is optional: a descriptor without its extensions falls back to the per-instruction display defined in sRFC 39.

The boundary both documents draw is identical. Merging and hiding change what the screen shows, never what is signed — the signed transaction always contains the full instruction list, and sRFC 41 requires wallets to offer an opt-in raw view. Ledger's implementation includes an advanced view that displays every instruction unprocessed.

That safeguard matters for bundles where a single label would be too convenient. A position that swaps, deposits collateral and borrows within one signature contains three distinct financial decisions. An intent screen that names the action but omits the amounts, the asset borrowed and the worst acceptable price would be a caption rather than a review.

Three Screens, Three Meanings

Because descriptor coverage is checked per instruction but applied per transaction, a Ledger user can now encounter one of three screens.

The first is the fully merged review: intents with their fields — the outcome the engine is designed to produce.

The second appears when every instruction has a descriptor but some value cannot be verified from the transaction itself. Those items are not merged away; they remain visible as separate steps with the gap explicitly named. Ledger's DFlow example reads "Swap (unknown sent amount)" alongside a quoted output in an unknown token — the device is telling the user precisely which number it could not confirm.

The third screen is the blind-signing warning, and it carries the least information as a direct result of the all-or-nothing rule. It means at least one instruction in the bundle has no signed descriptor. A coverage gap is not evidence of an attack — but it also removes the only tool the user had for telling the two apart. Rebuilding the same trade with different settings until the warning disappears is the wrong reaction, because the user would then sign a transaction that changed in ways they did not examine.

Practical guidance for each case:

  • Merged intents. Check the amounts against the dApp quote, then open the advanced view once and count the raw instructions — the fastest way to learn what a normal bundle for that dApp looks like.
  • "Unknown" in a field. Treat the unknown value as the amount actually at risk. If the dApp cannot state what that number will be before execution, that is the dApp's limitation, not the device's.
  • Blind-signing warning. Note which dApp and which action produced it. Confirm the Solana app is version 1.17.0 or later; if it is, the program is simply outside Ledger's current descriptor registry.

Who Wrote the Explanation on the Screen

A readable screen moves the trust question rather than eliminating it: the user is no longer trusting raw bytes, but trusting the descriptor that translated them. Ledger builds its descriptors from program IDLs in Codama format plus its own sRFC 39 and sRFC 41 overlays, drawn from a curated registry. Static descriptors are compiled into compact binaries and signed by Ledger's hardware security module. Dynamic descriptors — on-chain facts such as which account owns what — are fetched and signed by a Ledger backend and bound to a challenge from the device, so a stale or swapped response fails the check.

The security section of sRFC 39 explains why that signing chain exists. It requires implementations to verify that an IDL belongs to the program it describes and matches that program's on-chain upgrade authority, and it warns that an RPC provider could serve corrupted metadata or withhold updates. A polished description attached to the wrong program would be more dangerous than no description at all, because it would borrow the credibility of a name the user recognizes. The signed registry is the mechanism that makes a recognizable label worth something; the label on its own is not.

The registry is also the limit of the system. Ledger reports offline validation of roughly 57,000 transactions across 40 programs, naming Jupiter Aggregator v6, Jupiter Perps, Jupiter Lend, Kamino Lending, Kamino Liquidity and the OKX DEX Router among those covered, and listing Orca Whirlpool and DFlow among current limitations. The post says more programs will be added over time. Until a program enters the registry, every transaction touching it — however routine — produces the blind-signing warning.

Readable Is Not the Same as Safe

Three questions remain separate at the moment of approval: does the transaction request the actions the user intended, what will happen when it executes, and is the decision a good one? Clear Signing answers only the first. A correctly displayed borrow can still open an unsuitable debt position; a correctly identified token can still lose value; an owner can read a recipient address accurately and still send funds to the wrong one. Better presentation gives the user a chance to catch those decisions — it cannot make them on the user's behalf.

Ledger treats the second question as the domain of a separate product. Its Transaction Check feature simulates a transaction through outside security providers and displays a risk assessment on the device; Ledger's own documentation for it currently describes EVM transactions on Flex and Stax. A Solana user reading a clear-signed screen should therefore assume they are looking at a translation of the authorization, not a prediction of its outcome.

Before Trusting the First Readable Screen

The guidance for new users is concrete: run one small, familiar trade on a covered program and open the advanced view afterward. The point is to see how many raw instructions the engine folded into the intent that was approved, so that a later screen containing an extra step, an unknown field or a sudden blind-signing warning looks wrong immediately rather than merely unfamiliar.