Jito’s release of BAM (Block Assembly Marketplace) to the Solana Mainnet this past September brings verifiability to one of the fastest chains in crypto.
Solana transaction ordering determines which transactions are filled first and how fairly applications execute. But, until BAM, users and developers have had little visibility into how that ordering occurs, and they’ve had to trust validators to process transactions honestly.
BAM closes that gap by making the block-building process transparent, deterministic, and auditable, allowing anyone to verify how transactions were ordered. This transparency gives builders a way to prove execution fairness and ensure their applications perform as intended, rather than relying on trust in validator behavior.
In this article, we’ll explore why verifiability matters on Solana, how BAM brings transparency and auditability to block construction, and how Turnkey complements this by providing verifiable infrastructure at the signing layer.
Together, they deliver end-to-end verifiability for Solana builders, a key step toward a more transparent, auditable, and trustworthy onchain ecosystem.
Why verifiable ordering matters on Solana
Today without BAM, sequencing and block construction on Solana remain largely opaque, giving validators wide discretion to reorder or delay transactions. This control determines which transactions are included in a block and in what order they are executed.
Such opacity introduces bias and creates opportunities for manipulation, allowing validators and high-speed bots to reorder transactions and capture profits through maximal extractable value (MEV).
In validator parlance, MEV refers to the total value that can be extracted by reordering, inserting, or censoring transactions within a block before finalization. In practice, it represents the profits that block producers or bots can capture from normal onchain activity by exploiting control over sequencing.
Two common ways validators capture MEV are:
- Front-running:
A validator detects a profitable transaction and quickly submits its own just before it. When the victim’s transaction executes, the attacker sells at the higher price and captures the profit. - Sandwich attack:
The attacker places one transaction before and one after the victim’s trade. The first raises the price, the victim executes at a worse rate, and the second sells into the inflated price to pocket the spread.
For builders deploying protocols that depend on precise execution timing, such as decentralized exchanges or liquid staking systems, these distortions can break user trust and harm application performance.
Verifiability offers a clear alternative. It replaces discretionary and opaque behavior with deterministic ordering logic that anyone can inspect.
Through cryptographic proofs, attestations, and observable audit trails, builders can confirm how and why transactions were ordered.
Without verifiable ordering, builders face persistent risks: unpredictable execution, extractable value siphoned by faster participants, and a lack of transparency across the onchain flow of transactions. For a network that aims to be the fastest, ensuring fairness and auditability is what ultimately sustains confidence in its performance.
How BAM brings transparency and auditability to block building
BAM is a transaction sequencing network built specifically for Solana. It introduces verifiable logic to the block-building process, giving developers and validators the ability to confirm how transactions were prioritized and included.
At its core, BAM separates responsibilities within the network. BAM nodes handle the sourcing, prioritization, and filtering of transactions, while validators focus solely on execution and consensus. This division ensures that ordering decisions are transparent and traceable rather than dependent on validator discretion.
To protect privacy and ensure verifiability, BAM runs its sequencing logic inside Trusted Execution Environments (TEEs). Transactions remain private until execution, and every ordering decision is accompanied by a cryptographic attestation that can be independently verified.
Developers can also extend BAM through its Application-Controlled Execution (ACE) framework. ACE allows custom ordering logic, such as cancel-before-take rules for exchanges or oracle-update prioritization, to be built directly into the scheduling layer. This makes ordering both programmable and provable, aligning Solana’s block construction with the logic of the applications that depend on it.
The result is a transparent and auditable transaction flow for both builders and validators. With BAM, Solana’s block building becomes a verifiable process rather than a trust-based one, providing the foundation for a more fair and observable onchain economy.
How Turnkey complements BAM at the signing layer
While BAM brings transparency to Solana’s block-building process, full verifiability also depends on what happens before transactions are ordered.
Even if block construction is transparent, the signing layer, where keys authorize transactions or validator actions, can still introduce risk if it remains opaque or centralized.
Turnkey addresses this by providing a verifiable signing infrastructure purpose-built for developers who need trustless key management and auditability. To do this Turnkey also uses TEEs.
Keys are generated and stored within these Trusted Execution Environments, and every signing action is logged with cryptographic proof. This ensures that no sensitive operation occurs outside a verifiable, tamper-resistant environment.
For Solana builders, this creates full-stack verifiability, from sequencing to execution to signature. BAM ensures that ordering is fair and auditable, while Turnkey guarantees that key operations are isolated, verifiable, and traceable. Together, they close the loop on trust, giving developers the ability to build, prove, and operate onchain systems that are transparent at every layer.
“The point of blockchain is not transparency, it’s verifiability” –Mert, @0xmert, CEO of Helius Labs
End-to-end verifiability: From key generation to transaction execution
By combining BAM and Turnkey, Solana builders gain a verifiable foundation that extends from key generation to transaction execution. Each layer reinforces the other to remove uncertainty and prove correctness throughout the process.
With BAM, developers can rely on deterministic ordering logic backed by attestations that make sequencing auditable in real time. Ordering becomes rule-based rather than discretionary, enabling protocols to enforce fairness at the infrastructure level.
With Turnkey, the signing layer becomes verifiable and secure. Every key is protected inside a trusted execution environment, and every signing event is logged and provable.
Turnkey’s policy engine also enforces precise control over signing actions inside a secure enclave before any signature is produced. Builders can define conditions for when and how keys sign, such as restricting transactions to certain programs, wallets, or schemas.
With Turnkey’s Solana parser, these policies gain full protocol awareness. The parser interprets Solana-specific instructions, accounts, and program calls, allowing developers to permit or deny actions based on transaction content.
For applications that depend on precise performance this combination delivers better execution semantics and stronger integrity guarantees. Builders can define custom ordering rules that match their application logic, then trace every transaction from submission to inclusion to signature.
By integrating BAM and Turnkey, Solana’s infrastructure evolves from a system built on trust to one built on proof, a fully verifiable onchain stack ready for the next generation of high-performance applications.
Practical implications for Solana builders
For Solana builders, BAM and Turnkey introduce a new model for how infrastructure can be both high-performance and verifiable. Integrating these systems gives teams the ability to prove fairness, enforce signing policy, and observe their transaction flow from end to end.
Integration path:
Builders can adopt BAM-aware submission paths or build plugins that define transaction sequencing. These plugins set custom rules such as maker priority or oracle timing within the BAM scheduling layer, ensuring ordering aligns with application logic and is verifiable through BAM attestations.
Developers can also integrate Turnkey’s APIs for secure signing, key management, and policy enforcement, ensuring every transaction and signature can be traced and confirmed.
Example use cases:
- A decentralized exchange (DEX) seeking to guarantee maker-priority logic can implement it as a BAM plugin and use Turnkey to verify that all related signing actions occur under defined policies.
- A liquid staking or institutional protocol that requires provable audit trails for both ordering and signing can rely on BAM’s attestations and Turnkey’s immutable logs to meet compliance and reporting requirements.
- A high-frequency trading system can combine BAM’s deterministic sequencing with Turnkey’s low-latency, enclave-backed signing to maintain both speed and proof of correctness.
Monitoring and auditing:
Builders can continuously monitor BAM attestation data, which records how transactions were ordered, and Turnkey’s activity logs, which verify who signed and under what policy. Together, these data streams allow developers to reconstruct a full transaction lifecycle with cryptographic assurance at every stage.
Risk reduction and performance:
Using BAM and Turnkey reduces exposure to MEV exploitation, arbitrary validator behavior, and opaque signing operations.
Builders no longer need to rely on trust assumptions about sequencing or signing. They can point to cryptographic evidence of how every step occurred. The result is a measurable reduction in operational and execution risk, without sacrificing Solana’s hallmark speed or scalability.
For Solana’s developer ecosystem, this combination represents a shift from implicit trust to explicit proof. BAM and Turnkey establish a blueprint for building onchain systems that are verifiable and institution-ready, setting a new standard for fairness and auditability in high-performance blockchain infrastructure.
“This is one of the biggest changes in Solana’s history – private encrypted mempool (no sandwiching), app-specific sequencing (build onchain CLOBs), and verifiable ordering (institutions can build without the worry of MEV).”–Mert, @0xmert, CEO of Helius Labs
Looking ahead: Verifiable ordering and signing
As BAM matures and gains greater decentralization and plugin diversity, Solana’s block construction will become more modular, auditable, and application-controlled. Builders will be able to define their own ordering logic and verify exactly how it is applied through onchain attestations.
With Turnkey’s verifiable infrastructure, the full transaction lifecycle, from submission to sequencing, execution, and signing, becomes observable end to end.
Over time, Turnkey’s verifiability roadmap extends beyond onchain activity to Turnkey Verifiable Cloud, ensuring that offchain complex workloads can be audited from source to runtime.
For Solana builders, this convergence means operating with stronger guarantees, richer audit trails, and measurable proof of correctness. BAM delivers transparency in block construction, while Turnkey brings verifiability to every key operation, transforming both layers into independently provable systems.
Together, they position Solana as a verifiable blockspace platform where fairness, auditability, and developer control are built in. This is the path toward a more open, institutional-grade ecosystem, an “onchain NASDAQ” where every block, signature, and rule can be verified rather than trusted.
Turnkey x BAM: Verified Solana transaction infrastructure
The future of Solana depends not only on its speed but on the ability to verify every step of how transactions are created, ordered, and signed. As the network scales, transparency and proof have become as critical as performance.
BAM delivers this at the block-building layer. By introducing deterministic sequencing and verifiable attestations, it turns transaction ordering from a black box into an auditable process. Builders can see how their transactions are prioritized, confirm fairness in execution, and ensure their application logic is respected throughout the ordering flow.
Turnkey extends this same level of assurance to the signing layer. Each critical key operation takes place inside a secure enclave, producing cryptographic proofs and detailed audit logs. Every signature can be tied back to a verified environment and a specific policy, allowing developers to prove that authorization happened safely, predictably, and under explicit control.
Together, BAM and Turnkey form a verifiable transaction stack for Solana, one where trust is replaced by evidence. From creation to sequencing to signing, each action in the transaction lifecycle can be inspected, proven, and reproduced.
For Solana builders, this marks the beginning of a new phase in blockchain infrastructure: one where performance and transparency coexist. By integrating BAM plugins and Turnkey signing flows, developers can bring verifiable, auditable execution to their applications and help shape a Solana ecosystem built on proof rather than assumption.
Get started with Turnkey today.
Related articles
.png)
.png)
