Blockspace reservations

[mempirate]

Overview

A regular inclusion preconfirmation has the following limitation:

• Users must know the exact transaction they want to include before they can get an inclusion guarantee

This limits some use cases, specifically for protocols that need inclusion guarantees before they know exactly what transactions they want to include. An example of this is a blockspace futures protocol like XGA and their β-blockspace. Before minting blockspace tokens, they need some guarantees of inclusion even though they don't know what those tokens will "materialize" to. The capacity of the β-blockspace is fixed by how much they know for a fact they will be able to include.

Blockspace Claims

This could potentially be solved by introducing the blockspace claim as a new commitment type. However, the blockspace claim introduces a lot of complexity and requires an acceptable solution to the fair-exchange problem, especially in a completely trustless environment (i.e. any untrusted user can buy claims from any untrusted validators). This will take a lot of time, and we would like to be able to accomodate protocols like the one described above more quickly.

Blockspace Reservations

If we can relax the trust assumptions between users or protocols and validators, we can create a middle ground we'll call a blockspace reservation. Protocols can enroll into the registry with a signing key which will uniquely identify them, along with some metadata about their use cases. Validators can then choose to set some reservations for these protocols in terms of gas. They are then expected to reserve this gas (up to some deadline) for any incoming requests signed with the protocol signing key.

Implementation

• The registry will have some state about protocols:

struct Protocol {
    address pubkey;
    uint deadline; // Expressed in seconds before actual proposal
}

// Map of protocol IDs to Protocol
mapping(bytes => Protocol) protocols

• Validators can then set reservations which they are expected to honor:

function reserve(bytes protocolId, uint256 gas)

Protocols can then read the reservations they have as soon as they know the lookahead (omitting some steps here) by reading the contracts. They can then send their inclusion preconfirmations with guaranteed acceptance once they have the transactions and the deadline arrives.