Development of Solutions on the Modular Stack (Execution + DA + Settlement)
A monolithic blockchain does everything itself: executes transactions, ensures data availability, and finalizes state. The modular approach splits these functions between specialized layers. The result — an ecosystem where you can choose components as modules: Celestia for DA, Ethereum for settlement, OP Stack or Arbitrum Orbit for execution. This is not theory — dozens of mainnet L2 and L3 are built this way. We offer turnkey development of such solutions. Contact us for a consultation — we will evaluate your project and help you choose the optimal stack.
Many clients want their own appchain with low fees, custom logic, and Ethereum's security. This is a well-defined task, and the modular stack is the right answer. Our team has over 7 years of blockchain experience and has delivered 20+ projects, including 15+ production rollups, saving clients up to $500,000 annually on DA costs. We launched mainnet projects that reduced costs by 90-95% compared to traditional rollups.
Cost Advantages of a Modular Stack
The main argument is savings on the DA layer. Using Celestia instead of Ethereum to publish batch data reduces costs by 90–95%. For a high-volume rollup, this saves $2,000–$5,000 per month (up to $60,000 annually). Development costs range from $150,000 to $300,000 depending on complexity, but the total cost of ownership is often lower than monolithic alternatives because of reduced infrastructure and maintenance. Celestia is 20 times cheaper than Ethereum with comparable security for most scenarios. According to official Celestia documentation, Data Availability Sampling allows light nodes to verify data availability without downloading full blocks.
Layers of the Modular Stack
Execution Layer
Executes transactions, maintains state. This is your chain — with its own rules, gas token, precompiles.
OP Stack (Optimism, Base, Zora) — the most mature framework for Optimistic Rollup-based L2/L3. EVM equivalence. op-geth + op-node + op-batcher + op-proposer.
Arbitrum Orbit — Arbitrum-based L2/L3. Supports Stylus (WASM smart contracts in Rust/C++). More flexible gas customization and permission models.
Polygon CDK — ZK-based chain development kit. zkEVM under the hood. More complex to operate, but ZK finality instead of fraud window.
Sovereign rollup via Rollkit — execution layer with any execution environment, settlement in any chain (or without settlement). Maximum flexibility, minimum maturity.
Data Availability Layer
Blocks must be downloadable — otherwise fraud proofs and state reconstruction are impossible. The DA layer stores transaction data (calldata or blobs).
Ethereum L1 (EIP-4844 blobs) — maximum security, highest cost. After EIP-4844: ~3–6 blobs per block, each blob ~128KB, blob gas cost separate from execution gas. Blobs are deleted after ~18 days, but the commitment (KZG) remains forever.
Celestia — specialized DA layer. Data availability sampling (DAS): light nodes check availability through random sampling without downloading the entire block. Cost is orders of magnitude lower than Ethereum blobs with comparable security guarantees for most use cases.
EigenDA — DA layer on top of Ethereum via EigenLayer restaking. Economic security from restaked ETH. Significantly higher throughput than Ethereum L1 with higher security guarantees (as of now).
Avail — DA layer with data availability sampling, forkless upgrades. A good alternative to Celestia.
Settlement Layer
Finalization: determines the canonical state of the rollup. Handles withdrawals, resolves disputes.
For most projects — Ethereum mainnet via L1 bridge contract. Alternative for L3 — use L2 as settlement layer (e.g., Arbitrum One as settlement for Orbit chain).
How to integrate Celestia DA into OP Stack?
Step-by-step instructions for a production-ready configuration:
- Deploy a Celestia light node and get the auth token.
- Reserve a unique namespace (29 bytes).
- Implement an AltDA provider that implements GetInput and SetInput interfaces.
- Configure op-batcher to use Celestia as DA layer.
- Deploy OptimismPortal and L2OutputOracle contracts on Ethereum L1.
AltDA provider for Celestia
// Implementation of AltDA provider for Celestia
type CelestiaAltDA struct {
da *CelestiaDA
}
func (c *CelestiaAltDA) GetInput(ctx context.Context, commitment []byte) ([]byte, error) {
height, err := decodeCommitment(commitment)
if err != nil {
return nil, err
}
return c.da.Retrieve(ctx, height)
}
func (c *CelestiaAltDA) SetInput(ctx context.Context, data []byte) ([]byte, error) {
height, err := c.da.Submit(ctx, data)
if err != nil {
return nil, err
}
return encodeCommitment(height), nil
}
op-batcher configuration for Celestia
[da]
type = "celestia"
rpc = "http://celestia-light-node:26658"
auth_token = "${CELESTIA_AUTH_TOKEN}"
namespace = "0x0000000000000000000000000000000000yournamespace"
L1 Settlement Contracts
Two contracts are deployed on Ethereum. OptimismPortal — entry/exit point for cross-domain messages and withdrawals. L2OutputOracle — stores state roots proposed by the proposer.
contract L2OutputOracle {
struct OutputProposal {
bytes32 outputRoot;
uint128 timestamp;
uint128 l2BlockNumber;
}
OutputProposal[] public l2Outputs;
address public proposer;
uint256 public constant FINALIZATION_PERIOD = 7 days;
function proposeL2Output(
bytes32 _outputRoot,
uint256 _l2BlockNumber,
bytes32 _l1BlockHash,
uint256 _l1BlockNumber
) external payable {
require(msg.sender == proposer, "Not proposer");
require(blockhash(_l1BlockNumber) == _l1BlockHash, "Bad L1 block");
l2Outputs.push(OutputProposal({
outputRoot: _outputRoot,
timestamp: uint128(block.timestamp),
l2BlockNumber: uint128(_l2BlockNumber)
}));
}
}
Customizing the Execution Layer
Custom Precompiles
Precompiles are precompiled contracts at fixed addresses with native implementation. For example, add BLS12-381 operations or a custom hash algorithm:
var CustomPrecompiles = map[common.Address]vm.PrecompiledContract{
common.HexToAddress("0x0000000000000000000000000000000000000100"): &blsG1Add{},
common.HexToAddress("0x0000000000000000000000000000000000000101"): &customHashFunction{},
}
type blsG1Add struct{}
func (c *blsG1Add) RequiredGas(input []byte) uint64 { return 500 }
func (c *blsG1Add) Run(input []byte) ([]byte, error) {
if len(input) != 128 {
return nil, errors.New("invalid input length")
}
p1 := new(bls12381.G1Affine)
p2 := new(bls12381.G1Affine)
p1.Unmarshal(input[:64])
p2.Unmarshal(input[64:])
result := new(bls12381.G1Affine).Add(p1, p2)
return result.Marshal(), nil
}
Gas Token Customization
OP Stack supports Custom Gas Token — a native gas token different from ETH. This allows you to use your ERC-20 token as gas. Constraint: the custom gas token must be deployed on L1, have a standard ERC-20 interface, and have no transfer fees (rebasing/fee-on-transfer tokens are not supported).
Fee Structure and Sequencer Revenue
User Transaction Fee = (base_fee + priority_fee) * gas_used + L1 data fee
Sequencer Revenue = collected fees - DA costs - L1 costs
When using Celestia instead of Ethereum for DA, the L1 data fee drops by 90–95% for most transactions.
What's Included in the Work
- Requirements analysis and stack selection (OP Stack, Celestia, Ethereum) with justification.
- Development and deployment of core contracts (bridge, L2OutputOracle, OptimismPortal).
- Integration of a custom DA provider for Celestia.
- Execution layer setup (custom precompiles, gas token).
- Testnet deployment, writing test suites, and stress testing.
- Smart contract audit (bridge, fault proof) and vulnerability fixes.
- Assistance with mainnet launch, monitoring, and post-launch support.
- Documentation of architecture, deployment, and operations.
- Access to source code repository and deployment playbooks.
- Training for your team on operation and maintenance.
Comparison of DA Layers
Detailed comparison
| Parameter | Ethereum L1 (blobs) | Celestia | EigenDA |
|---|---|---|---|
| Security | Maximum | High (DAS) | Economic (restaking) |
| Cost | High | Low | Medium |
| Throughput | ~0.5 MB/s | ~1 MB/s | ~10 MB/s |
| Finalization time | ~15 min | ~30 sec | ~10 sec |
| Maturity | Production | Production | Beta |
Timeline Breakdown
| Phase | Content | Duration |
|---|---|---|
| Design | Stack selection, namespace, tokenomics, bridge design | 2–3 weeks |
| Core setup | op-stack deployment, L1 contracts, genesis | 3–4 weeks |
| DA integration | Celestia/EigenDA connector, batcher config | 2–3 weeks |
| Testnet | Public testnet, bridge testing, stress test | 3–4 weeks |
| Security | Bridge contract audit, fault proof testing | 4–6 weeks |
| Mainnet | Deployment, sequencer ops, monitoring | 2–3 weeks |
The critical path is the bridge contract audit. The bridge is where users' real money lives, and it's where most L2s have found critical vulnerabilities. Skimping on the bridge audit is not an option.
Total: 16–23 weeks from start to mainnet. Team: 2–3 backend engineers with Go experience, 1 Solidity developer, a DevOps/infrastructure engineer.
Ready to discuss your project and propose the optimal solution. Get a consultation — contact us.
Our Track Record
Since 2017, we have delivered 20+ blockchain projects for startups and enterprises. Our team combines 7+ years in distributed systems and 5+ years in Ethereum ecosystem. We have successfully launched multiple L2 and appchain mainnets, including integrations with Celestia and EigenDA. Our clients benefit from our deep expertise and reduce development risk.
Key metrics:
- 7+ years of blockchain experience
- 20+ blockchain projects delivered
- 15+ production rollups
- 5+ years in Ethereum ecosystem