The Filler Economy

MEV is extractive. Searchers front-run your trades, sandwich your swaps, and capture value that should be yours. The Ethereum community has spent years building infrastructure to mitigate MEV—Flashbots, MEV-Share, order flow auctions—all attempting to return some extracted value to users.

The same actors who extract value on Ethereum provide value on Signet. Signet’s settlement system turns searchers into Fillers—market participants who compete to give users better execution, not worse. They’re not extracting from your order; they’re fulfilling it. The incentives flip.

The Seven-Day Exit

On most rollups, moving assets back to Ethereum means locking them, waiting through a 7-day fraud proof window (or proof generation for zk rollups), and finally claiming on L1. Your capital sits idle for days. Professional market makers won’t deploy capital that can’t move. Users avoid withdrawals entirely, fragmenting liquidity across chains.

A 7-day delay is a 2% annual drag on capital at 10% APY alternatives. For a market maker with $10M deployed, that’s $200K/year in opportunity cost.

Markets, Not Queues

Signet replaces withdrawal queues with markets. Instead of waiting for proofs, users create Orders—signed intents that say “I’ll give you X on Signet if you give me Y on Ethereum.”

Fillers compete to fulfill these orders. The best price wins. Settlement happens in the same block.

How It Works

1. User creates an Order

Orders express atomic intent through Permit2:

pub struct SignedOrder {
    pub permit: Permit2Batch,      // Single signature authorization
    pub outputs: Vec<Output>,      // What user wants to receive
}

pub struct Output {
    pub token: Address,            // Asset (e.g., WETH)
    pub amount: Uint<256, 4>,      // Amount (e.g., 1 ETH)
    pub recipient: Address,        // Where to send it
    pub chainId: u32,              // Which chain (1 = Ethereum)
}

2. Fillers compete

Orders broadcast to the transaction cache. Multiple Fillers evaluate simultaneously:

• Can I fill this profitably?
• Do I have inventory on the destination chain?
• Can I beat competing Fillers?

3. Winner fills atomically

The winning Filler constructs a bundle: their fill transaction on Ethereum, the user’s order transaction on Signet. Both execute in the same block—or neither does.

The OrderDetector

Atomicity is enforced by the OrderDetector—an EVM inspector that validates every Order has corresponding Fills before allowing execution. Conceptually:

1. Fills execute first, crediting outputs to recipients
2. Orders execute, debiting inputs from users
3. The detector validates: for each output in the Order, does a sufficient Fill exist?
4. If any Fill is missing, the entire Order reverts

Fill transactions must execute before Order transactions. If any Fill is missing, the entire Order is rejected. No partial executions. No stranded assets.

Extraction vs. Service

Traditional MEV is a zero-sum game: searchers profit by taking from users. Signet’s Filler economy is positive-sum: Fillers profit by providing a service users want.

The difference is who initiates:

• MEV: Searcher observes user’s pending transaction, constructs attack
• Filler: User broadcasts intent, Fillers compete to fulfill it

Users set the terms. Fillers compete on price. The best offer wins. If no Filler accepts your order, it doesn’t execute — market liveness replaces proof liveness, and you can’t force-withdraw without a counterparty. Different from proof-based systems, not necessarily worse.

Multiple Fillers evaluate each order simultaneously. Competition drives spreads toward equilibrium, with price discovery occurring every 12 seconds. No single Filler controls market pricing — capital availability determines fill rates, and in a competitive market, spreads approach the cost of capital plus operational overhead.

Capital That Moves

Capital that settles in 12 seconds can be redeployed in the next block. Capital locked for 7 days sits idle.

Same-block settlement makes strategies practical that don’t work with async finality. Fillers can execute multiple trades within a single block and compound returns through circular trading paths. They can optimize cross-chain balances in real time, provision liquidity just-in-time, and net positions across multiple orders in the same block to reduce transaction costs. None of this is possible when capital is locked in a withdrawal queue.

Building a Filler

Fillers implement custom market-making strategies. Here’s the pattern (see signet-orders for a complete implementation):

// Example strategy pattern — implement your own evaluation logic
struct MyFiller {
    min_margin: f64,
    inventory: InventoryManager,
}

impl MyFiller {
    async fn evaluate_order(&self, order: &SignedOrder) -> bool {
        // Calculate potential profit
        let profit_margin = self.calculate_margin(order);

        // Check inventory on destination chain
        let has_liquidity = self.inventory.has_sufficient(order).await;

        // Decide whether to fill
        profit_margin > self.min_margin && has_liquidity
    }
}

Bundle Construction

Fillers aggregate orders into atomic bundles:

async fn construct_bundle(&self, orders: &[SignedOrder]) -> Result<SignetEthBundle> {
    let aggregated = self.aggregate_by_chain(orders);
    let signed_fills = self.sign_fills(&aggregated).await?;
    let txs = self.sequence_transactions(&signed_fills, orders).await?;
    let host_fills = signed_fills.get(&ETHEREUM_CHAIN_ID);

    Ok(SignetEthBundle {
        host_fills,
        bundle: EthSendBundle {
            txs,
            block_number: self.target_block(),
            reverting_tx_hashes: vec![],
        },
    })
}

Error handling is atomic:

• Invalid signatures → Bundle rejected pre-execution
• Insufficient liquidity → Fill transaction reverts, Order rejected
• Gas exhaustion → Entire bundle fails

Settlement as Infrastructure

Signet embeds market mechanics at the protocol level.

Every application built on Signet inherits instant cross-chain settlement. No integration required—it’s how the chain works.

Get Started

For Fillers:

• Signet SDK: Complete implementation patterns
• Bundle simulation: Pre-execution validation

For Builders:

• Orders documentation: How orders work
• SDK types: Type-safe order handling

Questions? Get in touch.