Rebindable Transaction
A rebindable transaction allows its signing context to be swapped to a different input, enabling flexible pre-signed transaction schemes.
Key Takeaways
- A rebindable transaction is a pre-signed Bitcoin transaction whose signature remains valid even when it is attached to a different input UTXO, removing the rigid binding between a signature and a specific outpoint.
- BIP 448 formalizes this capability by bundling OP_TEMPLATEHASH (BIP 446), OP_CHECKSIGFROMSTACK (BIP 348), and OP_INTERNALKEY (BIP 349) into a Taproot-native covenant bundle.
- Protocols like Ark, LN-Symmetry (eltoo), and statechains benefit directly because they rely on large trees of pre-signed transactions that currently must be rebuilt whenever the underlying UTXO changes.
What Is a Rebindable Transaction?
A rebindable transaction is a pre-signed Bitcoin transaction that can be detached from its original input and reattached to a different UTXO without invalidating its signature. In standard Bitcoin transactions, a digital signature commits to the specific outpoint being spent. This tight binding means that if the input UTXO changes for any reason, every pre-signed transaction that references it must be re-signed from scratch.
Rebindable transactions solve this by separating what a signature commits to from which input it spends. The signature still enforces the transaction's outputs, locktime, and version, but it no longer names a fixed input outpoint. This makes the transaction portable: it can be "rebound" to spend any UTXO whose script matches the expected spending conditions.
The concept is formalized in BIP 448, a draft soft-fork proposal authored by Gregory Sanders, Antoine Poinsot, and Steven Roose. BIP 448 was merged into the BIPs repository as a Draft on March 17, 2026. It does not have a scheduled activation date.
How It Works
To understand rebindable transactions, consider how standard Bitcoin signatures bind to inputs. A typical sighash flag like SIGHASH_ALL causes the signature to commit to every field of the transaction, including the previous outpoint (the txid and output index of the UTXO being spent). If that outpoint changes, the signature becomes invalid.
BIP 448 achieves rebinding by combining three Tapscript opcodes that work together:
- OP_TEMPLATEHASH (BIP 446) computes a hash of the spending transaction's "template": the version, locktime, input sequences, outputs, and optionally the annex. This hash deliberately excludes the input outpoints, so the same template hash is valid regardless of which UTXO the transaction spends.
- OP_CHECKSIGFROMSTACK (BIP 348) verifies a Schnorr signature against an arbitrary message taken from the stack rather than the transaction's sighash. When that message is the template hash, the signature commits to the transaction shape without naming the input.
- OP_INTERNALKEY (BIP 349) pushes the Taproot internal key onto the stack so scripts can reference it without hardcoding a specific public key.
Signing Flow
A simplified rebindable transaction flow works as follows:
- A group of participants construct a transaction with defined outputs, locktime, and sequence values
- OP_TEMPLATEHASH hashes these fields, producing a commitment that omits the input outpoints
- Each signer produces a Schnorr signature over this template hash
- OP_CHECKSIGFROMSTACK verifies the signature against the template hash on the stack, using the key provided by OP_INTERNALKEY
- The transaction is now valid against any UTXO whose script path contains the matching Tapscript leaf
Script Example
A minimal Tapscript leaf enforcing a rebindable covenant might look like this:
# Tapscript leaf for a rebindable transaction
OP_TEMPLATEHASH # Push template hash onto stack
OP_INTERNALKEY # Push the Taproot internal key
OP_CHECKSIGFROMSTACK # Verify signature over template hash
# using the internal keyBecause the template hash excludes input outpoints, a valid signature for this script works regardless of which UTXO funds the transaction. The outputs, locktime, and sequences remain enforced.
Why It Matters
Many second-layer Bitcoin protocols rely on trees of pre-signed transactions to guarantee users can exit to the base layer without cooperation from a coordinator or counterparty. Today, every pre-signed transaction must reference a specific input UTXO. If that UTXO changes (because it was consolidated, spent, or replaced), the entire tree of pre-signed transactions becomes invalid and must be reconstructed.
Rebindable transactions eliminate this fragility. A tree of pre-signed exits can be constructed once and then reattached to a fresh UTXO whenever the underlying funding output rotates. This has several practical benefits:
- Reduced signing rounds: protocols that currently require all participants to re-sign whenever the shared UTXO changes can skip that ceremony entirely
- Lower coordination overhead: fewer real-time interactions between participants means better liveness and reduced failure modes
- Smaller on-chain footprint: exit transactions remain valid across UTXO rotations, so protocols can batch more aggressively without risking stale signatures
For a broader view of how covenant proposals compare, see the Bitcoin Covenant Activation: Path Forward research article.
Use Cases
LN-Symmetry (Eltoo)
LN-Symmetry is a proposed payment channel design that replaces the penalty-based enforcement of current Lightning channels with a "latest state wins" rule. Each channel update produces a new state transaction that supersedes all previous ones.
For this to work, each update transaction must be able to spend the output of any prior state, not just the specific one it was created against. Rebindable transactions provide exactly this: the update signature commits to the outputs (the latest balances) but not to the specific input outpoint. This allows the most recent update to be rebound to whichever prior state appears on-chain.
BIP 448 positions itself as a Taproot-native alternative to SIGHASH_ANYPREVOUT (BIP 118), which was the original mechanism proposed for LN-Symmetry. Both approaches achieve the same goal of input-agnostic signatures through different mechanisms.
Ark and Timeout Trees
Ark uses timeout trees: hierarchical structures of pre-signed transactions rooted in a single on-chain UTXO. Each leaf represents a user's virtual UTXO (vTXO), and the full tree guarantees unilateral exit paths for every participant.
Currently, constructing a timeout tree requires an n-of-n signing ceremony among all participants, because every transaction in the tree commits to a specific input. If the coordinator creates a new round (rotating the shared UTXO), a fresh tree must be signed from scratch. Rebindable transactions would let a covenant enforce the tree structure directly: the tree of exit transactions could be rebound to the new round's output without requiring another signing ceremony.
Statechains
Statechains transfer UTXO ownership off-chain by passing signing authority rather than broadcasting transactions. Each transfer produces a pre-signed exit transaction so the new owner can always claim the UTXO on-chain. Rebindable transactions would simplify this model by letting exit transactions remain valid even when the underlying UTXO is swapped or consolidated, reducing the need for the statechain entity to co-sign every transfer.
Vaults
Bitcoin vault designs use pre-signed transactions to enforce spending delays and clawback paths. Rebindable transactions would let vault operators rotate their cold storage UTXOs without invalidating the pre-signed recovery transactions, improving key management flexibility.
Relationship to Other Covenant Proposals
BIP 448 is one of several covenant proposals under discussion. Understanding where it fits:
| Proposal | Mechanism | Rebinding |
|---|---|---|
| BIP 119 (CTV) | Hash-based template verification | No: commits to input outpoints |
| BIP 118 (APO) | New sighash mode skipping input commitment | Yes: via SIGHASH_ANYPREVOUT |
| BIP 446 + 448 | Template hash plus stack-based sig verification | Yes: via OP_TEMPLATEHASH excluding outpoints |
| OP_CAT | Stack concatenation enabling introspection | Possible: with additional script construction |
BIP 448's authors position it as a Taproot-native approach that reuses existing BIP 341 sighash components, avoiding the introduction of entirely new sighash types. The tradeoff is that it requires three new opcodes rather than a single sighash flag change.
Risks and Considerations
Draft Status
BIP 448 is a draft proposal with no scheduled activation. It is available for testing on the Bitcoin Inquisition signet, but it has not been deployed to mainnet. Any protocol designs relying on rebindable transactions remain theoretical until the soft fork activates.
Security Surface
Decoupling signatures from inputs expands the set of UTXOs a transaction can spend. If the Tapscript leaf containing the rebindable covenant is accessible on multiple UTXOs with the same script, a single signed transaction could potentially spend any of them. Protocol designers must carefully restrict which UTXOs carry rebindable script paths to avoid unintended spending authorization.
Interaction with Existing Sighash Flags
Rebindable transactions introduce a fundamentally different signing model from traditional sighash flags. Wallet software, hardware signers, and PSBT tooling would need updates to correctly construct and validate these transactions. Misuse of rebindable script paths in wallet implementations could lead to unintended fund exposure.
Soft Fork Coordination
Because BIP 448 bundles three separate opcodes (BIPs 446, 348, and 349), activation requires consensus on all three simultaneously. Some community members have advocated for activating individual opcodes (such as CTV or CSFS alone), and the bundled approach adds to the ongoing covenant activation debate.
This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.