The introduction of the Soroban smart contract platform to the Stellar network brought a new metered resource model designed to price computation, storage, and ledger access. This model is the primary defense against denial-of-service and ledger bloat attacks, translating resource consumption into a fee for transaction submitters. Incidents in this category occur when an attacker discovers a discrepancy between the modeled cost of an operation and its real-world impact on the network, allowing them to execute a disproportionately expensive attack for a minimal fee.

Soroban Resource Pricing Exploits
Introduction
A record of incidents where attackers gamed the Soroban fee and resource model to execute cheap attacks, such as ledger bloat or denial-of-service against specific contracts.
These exploits are not necessarily flaws in individual smart contracts but are often attacks on the economic assumptions of the Soroban environment itself. An attacker might find a way to write excessive data to the ledger, trigger computationally intensive WASM execution paths, or force a cascade of internal contract calls at a cost far below the intended price floor. The operational impact can range from targeted denial-of-service against a specific contract to network-wide ledger bloat that increases hardware requirements and degrades performance for all validators.
For protocol architects and risk teams, each incident serves as a critical stress test of the compute, ledger read/write, and historical data fee dimensions. Understanding the precise mechanism of these exploits is essential for validators who must apply patches and for developers who need to design contracts resilient to resource exhaustion. Chainscore Labs can model the impact of proposed resource pricing changes and review contract architectures to identify resource exhaustion vulnerabilities before they are exploited on mainnet.
Incident Quick Facts
A structured breakdown of how attackers exploited the Soroban fee and resource model, the affected systems, and the operational actions required for detection and remediation.
| Attack Vector | Exploit Mechanism | Affected Systems | Operational Signal | Mitigation Action |
|---|---|---|---|---|
Ledger Bloat | Spamming contracts with cheap storage writes to inflate state size | Validators, Node Operators, Archival Services | Sustained spike in ledger entry growth vs. transaction fee revenue | Monitor state growth rate; review resource pricing for storage rent |
CPU Exhaustion | Executing computationally intensive WASM instructions at minimal cost | Validators, Soroban RPC Providers | High CPU utilization on validators during low-fee transaction bursts | Profile WASM execution costs; validate metering logic against actual resource consumption |
Memory Pressure | Allocating excessive memory within a single contract call to degrade node performance | Validators, Infrastructure Providers | Memory usage spikes correlating with specific contract invocations | Audit host function memory limits; enforce strict per-call memory budgets |
Cross-Contract Call Amplification | Chaining cheap cross-contract calls to multiply resource usage without proportional fees | Soroban Contracts, Indexers | Deep call stacks with low cumulative fees but high total resource drain | Review cross-contract call pricing; implement call depth or cost amplification rules |
Mempool Flooding | Submitting a high volume of low-fee Soroban transactions to congest the mempool | Validators, Exchanges, Wallets | Mempool size surge with transactions that pass fee checks but fail execution | Tune mempool admission policies; enforce stricter fee-to-resource ratios for Soroban txns |
WASM Metering Bypass | Crafting WASM bytecode that evades the cost metering logic, executing instructions for free | Soroban Runtime, Security Auditors | Discrepancy between metered cost and actual execution time for specific contracts | Fuzz test WASM metering; compare metered vs. wall-clock execution time for anomalies |
Contract State Bomb | Creating a contract with a massive initial state that must be loaded by all validators | Validators, Soroban RPC | High variance in block validation times when specific contracts are invoked | Cap initial contract state size; charge fees proportional to state bytes loaded |
Root Cause Pattern: Metering Mismatches
Attackers exploited discrepancies between the Soroban host function's actual computational cost and its modeled resource price to execute cheap denial-of-service and ledger bloat attacks.
The core vulnerability in Soroban resource pricing exploits is a metering mismatch, where the fee charged for a specific WASM instruction or host function is significantly lower than the real computational or storage burden it imposes on validators. In a correctly calibrated system, the CostType for each operation is set to create a direct, proportional relationship between the resources consumed and the fee paid, making abuse economically irrational. When this calibration fails, an attacker can construct transactions that consume disproportionate amounts of CPU cycles, memory, or ledger entry space while paying minimal fees, effectively creating a subsidy for a denial-of-service attack.
This pattern is not a flaw in Stellar's consensus mechanism but a failure in the economic security model of the smart contract platform. The Soroban environment relies on a sophisticated, multi-dimensional fee model to prevent such attacks, but the complexity of accurately metering every possible WASM operation and host function across all possible inputs creates a broad attack surface. An attacker only needs to find a single underpriced operation to exploit, while the protocol must correctly price every operation to be secure. This asymmetry means that metering mismatches are a systemic risk, not just isolated bugs, and require continuous, rigorous analysis as new host functions are added or existing ones are optimized.
For protocol architects and risk teams, this pattern underscores that a fee schedule is a critical security parameter, not just an economic one. A change to a CostType or the introduction of a new host function should be treated with the same security rigor as a change to the consensus protocol. The operational impact is severe: a successful exploit can degrade network performance for all participants, cause ledger bloat that increases hardware requirements for node operators, and force emergency patches that disrupt validator coordination. Chainscore Labs can model the impact of proposed resource pricing changes and conduct deep-dive reviews of Soroban contracts and their runtime dependencies to identify resource exhaustion vulnerabilities before they can be exploited.
Affected Systems and Actors
Soroban Developers
Developers deploying contracts on Soroban are the most directly affected. Resource pricing exploits can cause their contracts to become economically unviable or vulnerable to denial-of-service. An attacker can craft transactions that consume excessive CPU instructions or RAM without paying proportional fees, draining contract balances or bloating ledger state.
Action Steps:
- Audit contracts for unbounded loops, excessive data storage in a single invocation, and cross-contract calls that can be forced to consume high resources.
- Model worst-case resource consumption for every public function and compare it against the current fee schedule.
- Implement rate-limiting and authorization checks to prevent unauthorized resource consumption.
- Monitor Soroban's metering updates and CAPs that adjust cost models for host functions.
Impact and Attack Vectors
A breakdown of how Soroban's resource pricing model can be gamed, the resulting attack vectors, and the specific controls needed to mitigate them.
Ledger Bloat via State Expansion
Attackers can exploit underpriced write operations to store excessive data in the ledger, inflating state size for all validators. This increases operational costs for node operators through higher storage and I/O requirements, potentially degrading network performance. Mitigation requires modeling the long-term cost of state rent and increasing write fees to reflect true archival costs. Teams should audit contracts for unbounded storage patterns and monitor state growth anomalies.
Compute Metering Bypass
If the WASM runtime's instruction cost model is misaligned with actual CPU consumption, attackers can craft transactions that consume disproportionate compute resources for a minimal fee. This can lead to validator overload and denial-of-service against specific contracts. Defenses include rigorous benchmarking of host functions, dynamic cost calibration, and enforcing strict per-transaction compute limits. Chainscore can review contract logic for computationally expensive paths that could be exploited.
Cross-Contract Call Amplification
A single top-level invocation can trigger a cascade of cheap, nested cross-contract calls, multiplying the total resource consumption far beyond the initial fee. This vector can be used to exhaust ledger-wide resources or grief specific contracts. Protocol architects must enforce strict call depth limits and ensure that resource pricing accounts for the full call tree, not just the entry point. Contract developers should implement reentrancy guards and call-chain monitoring.
Fee Market Manipulation
By flooding the network with low-cost, resource-intensive operations, an attacker can displace legitimate transactions and drive up inclusion fees. This degrades user experience and can make certain dApps economically unviable. Soroban's fee model must include surge pricing mechanisms that dynamically adjust based on network load. Wallets and dApps should implement fee estimation logic that accounts for current resource contention.
Contract-Specific DoS via Resource Starvation
An attacker can target a specific contract by consuming all resources allocated to it within a ledger window, preventing legitimate users from interacting with it. This is particularly damaging for time-sensitive applications like auctions or liquidations. Mitigations include per-contract resource limits and priority fee mechanisms. Chainscore can model attack scenarios to help teams design contracts resilient to resource starvation.
Economic Model Review and Simulation
Validating the security of Soroban's resource pricing requires simulating adversarial behavior against the fee model. Chainscore Labs offers protocol impact assessments that model exploit economics, identify underpriced operations, and recommend parameter changes. This proactive review helps protocol architects and risk teams harden the network before exploits occur, ensuring the economic security model aligns with operational reality.
Risk Assessment Matrix
Evaluates the operational and economic risks posed by attacks that exploit Soroban's resource pricing model, identifying affected actors and recommended actions.
| Risk | Failure mode | Severity | Affected actors | Mitigation |
|---|---|---|---|---|
Ledger bloat via cheap storage | Attackers create excessive ledger entries by exploiting low-cost storage opcodes or metering gaps, inflating state size | High | Validators, Node Operators, Infrastructure Providers | Monitor state growth rates; validate against latest metering patches; review state archival policies |
CPU exhaustion via underpriced instructions | Malicious contracts consume disproportionate CPU time by targeting WASM instructions with inaccurate cost models | High | Validators, Soroban Developers, Exchanges | Profile contract CPU usage; apply Stellar Core updates; enforce resource limits in contract design |
Denial-of-service against specific contracts | Attackers spam a target contract with cheap cross-contract calls, exhausting its resource limits or triggering reverts | Medium | DeFi Protocols, Wallet Providers, Application Developers | Implement rate limiting and authorization checks; review cross-contract call patterns for abuse vectors |
Mempool flooding with low-fee transactions | Attackers fill validator mempools with resource-intensive but cheaply-priced transactions, delaying legitimate operations | Medium | Validators, Exchanges, Payment Operators | Tune mempool admission policies; monitor fee market dynamics; deploy transaction prioritization logic |
Economic invalidation of fee model | Persistent exploits undermine confidence in Soroban's fee predictability, making cost estimation unreliable for businesses | Low | Protocol Architects, Application Developers, Risk Teams | Model fee sensitivity to resource pricing changes; participate in governance discussions on parameter adjustments |
WASM runtime sandbox escape via metering bug | A flaw in the metering logic allows a contract to execute unbounded instructions, potentially crashing the validator process | Critical | Validators, SDF, Security Auditors | Apply emergency patches immediately; conduct fuzz testing on WASM runtime; review host function metering |
Cross-contract call depth exploitation | Deeply nested cross-contract calls exploit underpriced call frames to perform complex logic at minimal cost | Medium | Soroban Developers, Auditors, DeFi Protocols | Limit call depth in contract logic; audit for unbounded recursion; verify stack metering accuracy |
Detection and Prevention Checklist
A practical checklist for protocol architects, security auditors, and Soroban developers to detect resource pricing vulnerabilities and prevent economic denial-of-service attacks. Each item identifies a specific risk vector, explains why it matters, and provides the signal or artifact that confirms readiness.
What to check: For each host function invoked by a contract, calculate the maximum CPU instructions, memory allocation, and ledger I/O operations consumed under adversarial input conditions.
Why it matters: Attackers exploit functions where the cost to execute is lower than the cost to the network. A function that iterates over a user-supplied vector without a hard-coded bound can consume disproportionate resources relative to the fee paid.
Signal of readiness: A resource model document that maps each contract entry point to its worst-case resource footprint, with explicit bounds on loop iterations, storage writes, and cross-contract call depth. The model should be validated against Soroban's fee schedule to confirm that the minimum fee always covers the worst-case cost.
Source Resources
Use these sources to verify Soroban fee-metering behavior, resource limits, implementation changes, and incident-relevant release activity before changing application limits or operational controls.
Looking to build on a specific blockchain?
We build smart contracts, DeFi applications, wallets, tokenization platforms, and blockchain infrastructure across the major ecosystems teams choose today. That includes Ethereum, Arbitrum, Optimism, Polygon, Avalanche, Solana, Sui, Aptos, Hedera, Stellar, and NEAR, with support for additional EVM and non-EVM networks based on your product requirements.
EVM ecosystems
- Ethereum
- Arbitrum
- Optimism
- Polygon
- Avalanche
- Cronos

Non-EVM ecosystems
- Solana
- Sui
- Aptos
- Hedera
- Stellar
- NEAR
Additional ecosystems
- Polkadot
- Cosmos
- TON
- Cardano
- Algorand
- Tempo
Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.
Frequently Asked Questions
Common questions from protocol architects, risk teams, and node operators about the economic security of Soroban's resource model and the impact of pricing exploits.
A resource pricing exploit occurs when an attacker manipulates the fee and metering model of the Soroban smart contract environment to execute computationally expensive operations at a disproportionately low cost. This can lead to ledger bloat, denial-of-service against specific contracts, or degradation of network performance for legitimate users. Unlike a smart contract logic bug that steals funds, these attacks target the economic security layer itself, undermining the assumption that resource consumption is fairly priced.
Delivering blockchain solutions for 5+ years.
We have partnered with 50+ leading DeFi protocols, NFT ecosystems, and fintech innovators to build secure, scalable, and capital-efficient blockchain products.
Selected Partners & Clients
“I've been working with Chainscore Labs for last 3+ years, they've consistently delivered with strong ownership across multiple projects. The team is reliable and detail-oriented.”
How to get started?
If you're looking for blockchain integration, ChainScore Labs has 5+ years of experience helping teams build and integrate exchanges, wallets, smart contracts, tokenization solutions, and protocol-connected products, we can help you choose the right path, integrate securely, and get to production faster. Our team consists of experienced blockchain developers and architects who can help you with your blockchain integration needs.
Exploration & Strategy
Define your product goals and choose the right blockchain architecture for your use case.
Architecture & Design
Design the smart contracts, tokenomics, and security parameters of your system.
Development & Integration
Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.
Security & Launch
Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.
Discover our
blockchain development services.
We build production-grade blockchain solutions for top-tier projects across DeFi and Web3.
Need a blockchain engineering team?
Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.


