In the wastelands of X and other platforms of imitation, nuance is often abstracted. Binary outcomes and monolithic representations become the common ground, resulting in wasteful cognitive resources. Everywhere.
One must ask, when in history has there been a single, unified representation of the world?
The way we interpret information varies depending on the eye of the beholder, their context, and values. With this somewhat philosophical beginning of the piece behind us, It would be nonsensical to believe there is only one path-dependent way to build a distributed system.
Solana continues to embody these properties of iteration (“eating glass”) and has proven its non-fragility and resilience as it decouples itself from the cancerous overhang of FTX and now differentiates itself as the leading alternative general smart contract platform. And the most valuable realization is that this is still a non-consensus view.
Breakpoint 23’ presented a high signal/noise ratio, clearly emphasizing builders. This piece is orchestrated to initially dive into the unique technical properties of Solana (perused at breakpoint) and discuss how this informs a potential thesis going forward, Solana’s opinionated design decisions remain hyper-fixated on one giant global synchronous state machine that unifies the state of the world as fast as physics can allow.
Firedancer: the First Fully Independent Validator for Solana
Firedancer is an overhaul of Solana Lab’s original validator client, led by Kevin Bowers. I will not delve into the granularities of ‘why’ it’s so performant, but if you want to get your brain split like the Horcrux I implore the reader to watch this
“Relatively speaking, the speed of light got slower “ — Kevin Bowers
From a high level, Firedancer rewrites major functional components from the existing Rust validator one at a time:
- Transaction propagation: disperse transaction data from network users to the leader
- Transaction processing: Run the competition needed to execute transactions, replicate and maintain state
- Verify the validity of the new Merkle root
Dal Albert, describes the NUMA-aware, Tile-based architecture NUMA as a non-uniform memory access CPU. To maximize performance you need a system that is aware of latency between individual hardware components;
- Provides dedicated hardware resources per thread
- 1 CPU core per tile
- High-performance message passing between tiles
- Tiles optimized for memory locality resource layout and component latencies
The current version of Firedancer is live on testnet (Frankendancer), implementing all networking features such as QUIC, signature Ed25519 signature verification, block packing, shred signing, and Turbine (pre-consensus protocol).
QUIC is worth briefly discussing as it is a core protocol upgrade that went relatively unbeknown. QUIC is a standardized transport layer designed by Jim Roskind at Google in 2013. The implementation details and why QUIC is a replacement to TCP, check here
Previously, Solana implemented a UDP-based networking protocol to pass transactions between RPC nodes and the current block leader. During times of bandwidth saturation (sustained spam/noisy transactions), this was problematic due to UDP’s connectionless nature, inability to limit flow, and acknowledgment receipts such that there is no meaningful way to limit Gbps of transactions with no economic utility (e.g. bots). This resulted in DDoS attacks whereby an attacker spams the target with a large amount of data, preventing organic communications from reaching the block leader. If sophisticated attacker were to bypass RPC nodes and directly grief the leader with transactions, adverseries could essentially DoS grief leaders with transactions directly obRPC nodes with the leader schedule public. Note this public leader isn’t unique to Solan despite many people’s confusion
QUIC has the following benefits:
- Reduced connection establishment = lower latency
- QUIC can send multiple signals as one monolithic signal without head-of-line blocking, significantly optimizing transaction throughput
- Sessions and flow control = optimized and dynamic/adaptable data ingestion
QUIC is now the default transaction ingestion protocol over UDP, a massive improvement of liveness and a reminder that a transaction can only propagate as fast as its slowest component (Amdah’s law)
These performance benchmarks are impressive: 1m TPS per tile (per CPU core) handling multiple Gbps on a single core. Firedancer eradicates the constraints of software and simply “throws more cores at it.” Importantly, the hardware requirements are at parity with existing validators and as Moore’s law continues to hold, hardware specs will become cheaper/easier for more operators, increasing the diversity of participation while retaining higher performance capacity per node. Remarkably close to the physical capability of the underlying hardware.
These improvements make Solana+Firedancer the most performant execution environment and synchronous state machine by far. Comparatively;
Rollup throughput (post 4844- danksharding)
Simple napkin math enables a hypothesis of throughput when using Eth as the Data availability layer:
If have a gas limit of 15m gas per block and a block is every 12 seconds ~1m gas per second
- The cost per byte of calldata is 16 gas per byte divided by 1m gas/16 gas = 62000 KB/ second
- Avg transaction = 250 bytes
- 62000/250 bytes = 250 transactions per second. Adjusting for compression ~500 TPS
Thus, there is an apparent dislocation of performance that is not appreciated by the market. Firedancer increases throughput further than Nasdaq’s current TPS (20,000 TPS) and expands the design surface area for more sophisticated applications that are “only possible on Solana.”
Despite being commonly pointed out, I argue that although Firedancer is a distinct and independent client, I challenge this notion that its entrance furthers the resiliency of the validator set as the rational outcome is everyone just adopting Firedancer rather than a diverse group of clients.
Localised Fee Markets
Generally, public blockchains implement a fee mechanism to allocate scarce computational resources across competing transactions (right to be included in a block). Because full nodes have finite resources, blockchains limit the total amount of computational resources consumed per unit of time.
One-dimensional fee markets are commonly associated with single threaded runtimes. Conversely, how Solana’s Sealevel VM is architected requires users (devs) to specify the account their transaction will interact with ahead of time, specifying dependencies and executing independent (those not touching the same piece of state) transactions concurrently over different cores. This is an immense improvement over single-threaded runtimes, which depend on the prior transaction’s serial execution. Still, in reality, a large fraction of transactions often want to access the same accounts in scenarios like auctions and arbitrage opportunities, thereby limiting the potential benefits of parallelization.
This property enables multidimensional fee markets to price interactions with each account separately and charge higher fees for transactions that require sequential execution. This construction provides granularity and specificity to fees to achieves a higher utility function (more efficient allocation of resources) for both validators and end users.
Creating fee structures that are only possible on Solana;
- Users pay higher fees to execute their transactions with more/less parallelism, where each core is a dimension.
- Tighter relationship of program execution to physical execution leads to granular fee markets ( efficient reflection of true demand/supply)
As signified by Visa in their Solana deep dive, localized fee markets unlock predictable transaction costs that “drive payment efficiencies.” The essence is quite simple: why should I incur a negative externality perpetuated as exorbitantly high fees if I am not consuming/competing for those finite resources? Gwei on Eth repeatedly reaches 200–300 gwei, a homogeneous cost borne by all users, even if they are not in the same state. If the Bored ape NFT mint happened on Solana and I was a user competing to win a liquidation on Margin.fi, I would be economically dislocated from that activity.
Moving away from uniform resource pricing and towards independent fee markets reduces the variance in fees and is a UX/UI improvement that is uniquely viable on Solana (at least right now)
I want this piece to be something other than a technical expose, so I will avoid further depth. However, I suggest the reader peruses state compression and concurrent Merkle trees, but essentially, it enables the minting of 1m NFTs for $150. The equivalent would garner a $33,606,488 on Eth
Future Technical Roadmap
- Bankless leaders: blocked by scheduler improvements
- Diet clients: Data availability sampling
- Asynchronous program execution: separate vote program state
- Multiple concurrent leaders: Turbine uses Merkle proofs per batch, making it possible to do “DAS” like sampling to guarantee that blocks are propagated globally thus preventing fork attacks with concurrent leaders
- Storage dynamic pricing-
Galvanized Community: dApps, not Traps
Often, during adversarial duress, ecosystems can either collapse due to the existential risk (community falling apart) or embark on a hero’s journey of redemption.
Surviving one of the biggest frauds in the past decade seems to be $SOL’s religious moment, not dissimilar to Eth’s “DAO hack” in 2016 that drained 5% of all tokens and a coordinated hard fork that still is a slight tint on Eth’s credible neutrality meme. This was Sol’s “DAO hack” moment.
Given this was my first Sol-centric event, I do not have an anchor of previous events. Still, Solana founders have a unique and differentiated characteristic set, and this is the most critical metric as opposed to commonly cited vanity metrics such as TVL and DAU. These metrics give investors a dis-illisioned sense of accuracy around the explanatory variable of why ‘number go up’.
With this in mind, the intellectual capital and founders building things they wouldn’t or couldn’t build elsewhere within Solana is diverse and sticky due to numerous factors (perhaps one could be 2021’s wealth effect). This qualitative insight is by far the most critical metric in crypto. I was lucky to have vibrant conversions with user-oriented founders bewitched by their drive for PMF. This is a pleasant juxtaposition from the illusionary nerd sniping and research-driven applications on Ethereum (not all). This focus on “infra”, is not only isolated to Eth but the whole crypto space in general, with little urgency to collapse the marginal costs of production or to solve a worthwhile problem that is not just a romanticized vehicle for speculation.
That said, speculation is not inherently wrong; it can be leveraged as a potent form of resource allocation and user acquisition. However, I now feel the pendulum needs to swing to a product focus. We are in the “show me phase,” with Solana continually compounding user-led values. Whether that’s DePin protocols, payments, CLOBs, or dynamic creator-oriented marketplaces like Drip.haus, this notion seems ingrained into the community’s ethos and is once unique to Solana. Exclusivity brings value. If we want to find the next “killer” app on the balance of probabilities, it will likely be on Solana.
Monolithic v Modular
I could write a 10,000-word article diving into the various tradeoffs of having an integrated vs. modular design. Still, given the length of this piece, I will refrain because it has been discussed with brevity by others like Jon Charb, although I don’t necessarily agree with all the particulars touched on. It’s essential to grasp that the more technical reality is there is little to no distinction between them if you play them out to their extreme, but people are led to incorrectly believe you can’t do things of one another’s design. They are two different paths to the same outcome.
For instance, it’s commonly mistaken that Solana is restricted from implementing data availability sampling, which is ubiquitous with Celestia’s implementation of Solomon Reed erasure coding. With Tinydancer implementing light clients, a “consensus checks on Sol,” the tradeoff Solana has made for beefy hardware seems to be becoming less relevant as time moves to the right. The modular thesis seems to be born out of necessity as the state is being executed using the EVM, by default, you need many chains (without exploring VM designs) for usable blockspace. This is why people in this modular world have gotten excited about appchains. If you look at what you have today, the system doesn’t work as it is single-threaded. The other side of that is that you will see this consolidation and power law distribution, mainly because people are going to realize it is a must to scale this single execution environment for so many reasons;
- Dev complexity
Vitalik’s end game to block building:
Thus, despite many of the tribalistic views perpetuated by Ethereum’s somewhat binary supporters, the rational outcome of block production is to become a specialized market where domain expertise (building the most profitable block) dominates and thus centralizes due to implicit forces of maximum extractable value (MEV). Thus, the two design philosophies begin to look very similar if you take Sol’s and Eth’s endgame to their rational extremes. The only difference is Eth with liquidity/network effects and Solana scaling throughput of a monolithic base layer.
Thus, it begs the question, where should we spend our time?
Ethereum has become so consensus that our marginal time and dollar do not go as far given its expectations (perfect execution is required). Moreover, with a million homogenous appchains (blockspace), L2s beginning to “eat some of Eths lunch”, inferior trusted bridging, and a lack of applications, Solana seems to offer a differentiated and perhaps a more efficient allocation of capital moving forward.