Arkade extends the idea of the Bitcoin mempool to an offchain environment: the virtual mempool relays and validates offchain transactions before they are settled onchain. Arkade’s virtual mempool functions as a high-throughput environment where VTXOs are created, spent, and updated instantly without the latency or cost associated with transacting on the Bitcoin mainchain. This allows Arkade to deliver:
  • Instant preconfirmation of user transactions
  • Parallel execution through a directed acyclic graph (DAG)
  • Scalability without requiring global state or sequential processing

​
How It Works

When a user broadcasts a transaction to Arkade, the steps are as follows:
  1. Validation. The Arkade Operator checks the transaction request (handed in as an intent against the current VTXO set
  2. Cosigning. If valid, the request is forwarded to the Arkade Signer, which provides a cosignature
  3. Update. The virtual mempool DAG is updated immediately, making outputs from the transaction instantly spendable
This makes the system a real-time execution layer where financial applications can run without waiting for Bitcoin block confirmations.

​
DAG Structure

Arkade’s virtual mempool is structured as a directed acyclic graph (DAG):
  • Each node represents a transaction
  • Edges represent dependencies between VTXOs (inputs/outputs)
  • Independent branches can progress in parallel, enabling massive throughput
virtual-mempool-new.png
The DAG design avoids the bottlenecks of account-based systems, since transactions only need to respect their local dependencies, not a global serialized state.

​
From Preconfirmation to Finality

Transactions in the virtual mempool exist in a preconfirmation status:
  • They are instantly valid within Arkade once cosigned by the Arkade Signer
  • They can be chained and combined for further offchain activity
  • They have not yet attained Bitcoin finality
To attain full immutability, censorship resistance, etc, users eventually anchor their activity onchain via a batch swap, where the Operator batches and settles VTXOs onchain. At this point, VTXOs gain Bitcoin finality while retaining the flexibility of offchain programmability.
The virtual mempool is the engine that makes Arkade fast and scalable. By combining a DAG-based transaction model with cosigned VTXOs, it enables instant transaction execution and true parallelism across independent transaction chains

​
Considerations

  • Trust in Preconfirmation. Users trust the Arkade Signer not to cosign conflicting transactions. Any misbehavior is provable though and disincentivized by economic penalties
  • Exit Guarantees. Users can unilaterally exit by revealing their presigned transaction path, independent of the Operator or Signer
  • Scalability vs. Settlement. The virtual mempool optimizes for speed, while settlement on Bitcoin optimizes for security. Users choose their preference at will