0x09ae108a09ae…09ae1087
FE Covenants: Bitcoin Spending Rules Without a Soft Fork
Jeremy Rubin's May 2024 FE design would enforce Bitcoin covenants in signing keys without a soft fork — but it needs obfuscation-grade crypto that still runs at toy scale.

Outputs
Jeremy Rubin proposed FE-based covenants in May 2024 in a paper titled FE'd Up Covenants, avoiding a soft fork
A 2017 obfuscation implementation needed 3.7 hours, 120 GB of disk and 128 GB of RAM for a 12-bit pseudorandom function
FE was formalized by Boneh, Sahai and Waters in 2011; well-founded constructions only arrived in 2021
The general design f(k, tx, program, proof) is strictly more expressive than OP_CTV (BIP-119)
Bitcoin could enforce covenants without changing its consensus rules if signatures came from cryptographically restricted keys, according to a May 2024 paper by Jeremy Rubin, the original author of the OP_CTV proposal (BIP-119). His design, titled FE'd Up Covenants, moves the covenant out of Bitcoin Script and into the signing key using functional encryption (FE). Cointelegraph Research has now published its sixth technical installment on Bitcoin covenants, laying out how the scheme works and why it remains impractical.
The premise is simple to state. In ordinary public-key cryptography, a private key can sign any message. In an FE-based covenant, signing is restricted to a predefined set of valid transactions. Bitcoin nodes would verify those signatures with OP_CHECKSIG exactly as they do today, removing the need for a soft fork.
How does functional encryption restrict a key?
Functional encryption generalizes public-key encryption. Instead of one private key that fully decrypts a ciphertext, a master secret issues subsidiary functional keys. Each functional key reveals only one chosen function of the plaintext. A holder of the functional key for a function f can compute f(x) on ciphertext x, but never sees x itself.
Academics formalized FE in 2011, in work by Dan Boneh, Amit Sahai and Brent Waters. Constructions for arbitrary functions followed in 2013, but they carried polynomial-time overheads far beyond current hardware and rested on untested primitives called multilinear maps. Only in 2021 did researchers produce constructions from well-founded cryptographic assumptions, in principle opening a path to practical FE.
In a Bitcoin covenant, f is a signing function. Its output is a Bitcoin signature for a transaction tx, so it needs at least two inputs — hence Rubin's use of multi-input FE. A covenant permitting a single spending transaction, similar to OP_CTV, needs only two inputs. More expressive constructions take more arguments, as in Rubin's f(k, tx, program, proof).
Crucially, f does not sign directly with the private key k, which exists only in encrypted form. The function derives a new key pair by tweaking k with a hash of the covenant's spending policy. Signatures from f validate against the tweaked public key, not the base key P.
What does setup require?
An FE-based covenant needs a setup authority that generates both a Bitcoin key pair (k, P) and an FE key pair (a master secret msk and public key mpk). The authority publishes P, mpk, the encrypted k and the functional key for f, then must be trusted to destroy k and msk. If it does not, it could sign spends that violate the covenant. Once set up, the system supports an indefinite number of new covenants.
Each covenant gets its own key pair by tweaking (k, P) with its spending policy. The tweaked private key exists only inside f. Anyone who knows the policy hash can derive the public key and generate receiving addresses. In practice, addresses would commit to a 2-of-2 script requiring both a user-controlled signature and the FE signature, blocking unauthorized parties from triggering permitted transactions.
The general version, f(k, tx, program, proof), is strictly more expressive than OP_CTV. Rubin's function takes a program that checks a condition on the transaction at spend time, plus a zero-knowledge proof that the program accepts it. The proof lets f stay small — it verifies a succinct statement rather than interpreting arbitrary programs — and lets spending policies depend on data outside the transaction, such as off-chain computations.
Why is it infeasible today?
The obstacles are hard numbers. Goldwasser et al. (2014) built multi-input FE on indistinguishability obfuscation, and Ananth and Jain (2015) showed the two primitives imply one another. Rubin's design therefore requires something at least as hard to build as obfuscation itself.
Existing implementations run at toy scale. Carmer, Malozemoff and Raykova needed 3.7 hours in 2017 to obfuscate a 12-bit pseudorandom function — roughly 62,000 gates with a 64-bit key, far smaller than ECDSA signing on 256-bit numbers. The obfuscated program occupied 120 GB of disk, and a single evaluation ran 67 minutes on 128 GB of RAM. The authors called the result "still far from practical." Those costs would fall on the signature producer, not on Bitcoin nodes.
Practical FE schemes today cover only narrow function classes, such as the inner products of Abdalla et al. (2015), and Bitcoin's ECDSA signing is not among them. Rubin's own paper concedes the point, listing under-developed cryptography and the setup trust assumption as downsides. CTV-style opcodes remain far more efficient in bytes and verification, but require a base-layer change.
The next installment in the series covers Un-FE'd Covenants, Rubin's follow-up that replaces FE with oracle signers bonded through BitVM, and traces how [alloc]init's Bitcoin PIPEs moved from an FE design in 2024 to witness encryption in 2026.
via bips.dev (Original)
More from Tom Whitfield
Show full bio
News editor covering technology and product news in crypto and web3 industry at Mempool Brief.
1,374 articles