Skip to main content
Every Arkade transaction is a Bitcoin transaction that spends outputs whose spending paths the operator enforces. Before it cosigns, the operator checks the transaction against each path it spends and runs the Arkade Script of any path written in it. At the base, the transaction spends ordinary Taproot outputs, and Bitcoin confirms it like any other. With offchain execution, the transaction spends virtual outputs instead. It is a virtual transaction: complete and signed, but never broadcast. It executes as soon as the operator cosigns it, and a batch later settles its outputs on Bitcoin. The rest of this page covers virtual transactions.

Transaction Structure

An offchain spend is made of two kinds of Bitcoin transaction. For each virtual output it spends, a checkpoint transaction moves the funds into a checkpoint output. The virtual transaction then spends those checkpoint outputs and creates the new virtual outputs. Both carry an anchor output, which a fee-paying child transaction spends if they ever have to go onchain. A checkpoint output keeps the collaborative path of the virtual output it came from, and adds a path that the operator can spend alone after a delay. Checkpoints protect the operator: if someone unrolls an output that was already spent offchain, the operator only has to broadcast that output’s checkpoint transaction, instead of every later transaction in the chain. To spend, the wallet signs the virtual transaction and submits it together with the unsigned checkpoint transactions. The operator cosigns them and returns the checkpoints, and the wallet adds its own signatures to finalize the spend.

Worked Example

Alice pays Bob 1,000 sats from a 5,000-sat virtual output:
The SDK builds one checkpoint transaction, because Alice spends one virtual output, and one virtual transaction: Bob’s output uses the standard script of his address: a collaborative path for Bob and the operator, and an exit path that Bob can use alone after the operator’s exit delay. Alice’s change gets the same script with her key, and either output can be spent again as soon as the operator cosigns.

Preconfirmation

When the operator cosigns a transaction, the transaction is preconfirmed. Its outputs are spendable at once, with no wait for a Bitcoin block. A preconfirmed output relies on the operator: it must not cosign a conflicting transaction that spends the same input. To remove that reliance, settle the output in a batch. A settled output has full unilateral exit rights.

Transaction Chaining

Because each transaction’s outputs are spendable at once, you can chain transactions without waiting. Each new transaction spends outputs of the previous one. Chains move at the speed of the operator’s signatures, not of Bitcoin blocks. If a transaction in a chain is invalid or conflicts with another, the operator rejects it and every transaction that depends on it. Longer chains make unilateral exit more expensive, because each transaction in the chain, with its checkpoint, must go onchain for an exit. Settling in a batch swap resets the chain.

Offchain Execution

Offchain transactions don’t wait for each other unless one spends another’s output, so the operator can process many of them at once.

DAG Architecture

Offchain transactions form a directed acyclic graph (DAG). Each node is a transaction, and each edge records which earlier transaction’s output it spends. Independent branches execute in parallel. Only transactions that depend on each other run in order. No transaction waits on a global state, as in an account-based system.