Bitcoin Is Quietly Becoming a Settlement Layer for More Than Bitcoin
Most blockchain-for-business pitches ask you to leave the most secure ledger to get features, and a small group of designs now refuses that trade.
Settlement and execution are different jobs
Payments people separated these jobs long ago. When you tap a card, an execution system approves the purchase in seconds. The money moves through a settlement system later, under different rules and with different guarantees. The first system is built for speed and features. The second is built for finality, and nobody wants it to be clever.
Bitcoin sits at the settlement end of that spectrum by design. Its scripting language is intentionally not Turing-complete, with no loops, which is one reason it has stayed simple enough to trust. The cost of that simplicity is that richer logic, such as contracts and assets with rules attached, has to live somewhere else. The useful question for a business buyer is where it lives, and what you must trust once it does.
I see three answers. You can leave Bitcoin for a separate chain and bridge back. You can keep assets on Bitcoin and move the validation to the people who hold them. Or you can run a purpose-built engine whose only source of truth is the Bitcoin ledger. Each answer comes with a different trust bill, and the bill is the part vendors tend to skip.
Four designs and what each one asks you to trust
Liquid takes the first path. It is a federated sidechain in which a fixed set of functionaries, currently 15 members with an 11 of 15 quorum, produce blocks about once a minute and manage the peg. You get speed and confidential transactions. In return, you trust a known federation to run peg-in and peg-out. The members are identifiable institutions, which some enterprises find reassuring, and others see as a custodian by another name.
Stacks has a similar shape with different mechanics. Its sBTC peg is held by a signer set that must reach a threshold, which the documentation gives as 70 percent, before any bitcoin moves. The signers are named organizations, and the set rotates over time. You trust that threshold, and you also run on a separate chain with its own consensus rules.
Taproot Assets stays closer to Bitcoin. Assets are held in Bitcoin UTXOs and transferred in regular Bitcoin transactions, with the supporting proofs kept off-chain by holders and by servers called universes. The FAQ is candid about custody. Whether you are fully self-custodied depends on whether you hold both the keys to the Taproot output and the asset keys. Lightning Labs also says it is focused on stablecoin use cases first, which tells you where the product attention is going.
RGB goes furthest in the other direction. Its consensus paper, still a preprint, keeps contract state with the participants and describes a design that doesn't rely on Bitcoin for transaction ordering or state replication. That is elegant for privacy and scale. It also means the parties to a contract are responsible for holding and validating the data.
None of these designs is wrong. They answer different questions. A federation optimizes for named accountability, a signer set for a rich contract environment, a client-side design for privacy, and an anchored engine for a small trusted base. The mistake is buying one while believing you bought another.
Where OroBit fits
OroBit takes the third path. Its contract language, SCL, compiles to deterministic bytecode. A deployment anchors a commitment hash of the bytecode on Bitcoin, and each call is a Bitcoin transaction carrying a protocol stamp in an OP_RETURN output. The first input of a call must spend a named outpoint, which the documentation describes as protection against replay and front-running.
Nodes then do the engine's work. They watch Bitcoin, replay the stamped transactions through the virtual machine, and compute a Merkle state root for each block. The node documentation says nodes are not miners and that a node does not join consensus but proves state through deterministic replay against Bitcoin. Because Bitcoin can reorganize its recent blocks, the design keeps undo logs and a 144-block journal so a node can roll state back. There is no bridge in this path and no wrapped Bitcoin, because the contract state is derived from the Bitcoin transactions themselves.
The tradeoffs are real. Every contract call is a Bitcoin transaction, so throughput and fees follow Bitcoin. The engine is deliberately bounded, with documented ceilings of 100,000 instructions per call, a stack depth of 1,024, a call depth of 64, and 64 KB of storage per contract. The Lightning side, which handles faster asset transfers, runs through a hub that OroBit operates. The browser signer keeps keys on the client, and the same documentation says SCL on Lightning is under active development.
Why this matters for payments, stablecoins and tokenized assets
Payments want finality and low cost. A settlement layer with a long security record and a simple rule set gives you finality, and the engine above it can chase cost and features. If the engine fails or is replaced, the record underneath is still there to replay against. If a federated sidechain fails, the record is the thing in trouble.
Stablecoins add a different question. The ledger can prove that a token moved, but it cannot prove the reserves behind it. A bridge or a federation adds one more party between you and the asset, and each party needs its own diligence. The fewer parties in the settlement path, the shorter that list gets.
Tokenized assets add a legal question on top. A token is only as good as the claim it represents, and that claim lives in contracts, registries, and courts. No settlement layer fixes that, which is why I keep returning to the issuer and the legal wrapper when someone shows me a clean architecture diagram.
Speed deserves a fair hearing too. Bitcoin blocks arrive on a roughly ten-minute cadence, so anything that needs sub-second feedback has to run above the base layer. That is what Lightning channels are for, and it is also where the trust bill grows again, because channel operators, hubs, and watchers enter the picture. A good vendor will show you exactly which actions settle on the base ledger, which settle in a channel, and which happen only inside an application, because the three carry different guarantees.
If you want to test the replay claim yourself, the architecture suggests a concrete experiment. Run an independent node, replay the stamped transactions, and compare your state roots with the operator's. That is the kind of verification a replay design should make cheap, and a vendor that encourages it is telling you something about its confidence.
System of record, system of engagement
Here is the executive version: Enterprises already run two kinds of systems. A system of record holds the facts you cannot afford to dispute, such as balances, ledgers, and title. A system of engagement is where customers and staff interact with those facts, with all the speed and feature churn that implies. Most blockchain pilots blur the two and then discover that the engagement layer carries record-layer risk.
The settlement-layer idea separates them cleanly. Bitcoin is the system of record, chosen in my view because it has the longest security history and the fewest moving parts. The engine, the Lightning channels, and the applications are the system of engagement, and they can be upgraded or replaced without rewriting history. That separation is the real product, no matter which vendor delivers it.
I wrote earlier that reversibility is the governing criterion for deciding how much autonomy to give an agent. The same logic applies here. Settlement is where reversibility ends, so it deserves the plainest and best-tested technology you can find, and the features can live one layer up.
Disclosure: I'm an investor in OroBit.