Someone pays you $20 in PUSD, a dollar token on Bitcoin Cash. You try to send $5 of it on, and your wallet may refuse: every transaction needs a miner fee paid in BCH, and you hold none you can spend. The usual answer is "go buy some BCH first", which is exactly where a new user stops.
I built FeePass for BCH BLAZE 2026 to remove that step. It is live on mainnet, the code is on GitHub, and the first sponsored send is on chain: d59f120b…f8b7. This post is about the one design decision that shaped everything else: why the sender still pays, and why they pay in dollars.
The shape: one ordinary transaction
A FeePass send is a single transaction with a fixed shape:
- in0 is your PUSD coin, signed by your own wallet.
- in1 is one "lane" of a sponsor pool: a UTXO locked by a CashScript covenant. Nobody signs it.
- out0 sends PUSD to the recipient, out1 is your PUSD change.
- out2 is the lane going back to the pool, minus the miner fee, plus exactly 0.01 PUSD.
The lane's BCH pays the miner. Your wallet never touches BCH. On mainnet that first send looked like this: 572 bytes, a 580-sat miner fee paid by the lane, and the sender's spendable BCH was 0 before and 0 after.
The wall: a covenant cannot remember you
My first idea was the obvious one: free sends, a few per person. A paymaster with a budget.
That does not survive contact with a covenant. A covenant is a spending condition on one coin. It can read the transaction it is being spent in (inputs, outputs, values, token amounts) through native introspection, but it has no memory across transactions and no notion of "a person". A rule like "at most 3 free sends per user" needs to know who the user is and what they did yesterday. Any limit keyed to an address is defeated by generating a fresh address, which costs nothing. Free sends from a covenant are drainable by anyone with a loop.
You can move that memory off-chain into a server that co-signs every transaction, which is roughly how fee-payer relayers work elsewhere. But then the sponsor key is online, the server is the trust model, and the rule no longer lives on chain.
The fix: make every send pay for itself
So the covenant does not try to recognise anyone. Instead, every send must leave the pool better off in dollars than it was in sats:
// R4 hard per-transaction cap on what the lane can lose.
require(tx.outputs[2].value >= tx.inputs[1].value - maxSubsidy);
// R5 the pool receives exactly feeTokens PUSD: never less, never more.
require(tx.outputs[2].tokenCategory == pusdCategory);
require(tx.outputs[2].tokenAmount == tx.inputs[1].tokenAmount + feeTokens);
maxSubsidy is 2,000 sats: the most one lane can lose in one transaction. feeTokens is 1 base unit of PUSD, which is 0.01 PUSD. As long as 0.01 PUSD is worth more than 2,000 sats, draining the pool costs the attacker more than it takes, no matter how many addresses they generate. The deploy script refuses parameters without a 1.5× margin; at the price it checked when the lane was funded (BCH $192.64), a standard send costs the lane 580 sats, about $0.0011, and pays the pool $0.01.
It is an equality on purpose. "At least 0.01 PUSD" would let a buggy client overpay; "exactly" means the pool's side of the transaction is fully determined.
The rest of the rules
The covenant's paid path is short enough to read in one sitting. The full file is contracts/FeePassPool.cash:
function sponsorPaid() {
// R1 fixed shape: exactly one user input, one pool input, three outputs.
require(tx.inputs.length == 2);
require(tx.outputs.length == 3);
require(this.activeInputIndex == 1);
// R2 the user brings PUSD and sends PUSD.
require(tx.inputs[0].tokenCategory == pusdCategory);
require(tx.outputs[0].tokenCategory == pusdCategory);
// R3 the lane returns to the same covenant.
require(tx.outputs[2].lockingBytecode == tx.inputs[1].lockingBytecode);
// R6 the user-side outputs may exceed the user's input sats by at most maxTopUp
require(tx.outputs[0].value + tx.outputs[1].value <= tx.inputs[0].value + maxTopUp);
// ... R4, R5, R7, R8
}
R6 exists because token outputs need dust. A partial PUSD send creates two token outputs of about 650 sats each, and a small user coin may not carry enough. The lane may top that up by at most 675 sats per send. On the first mainnet send, the lane's total cost was 882 sats: the 580-sat miner fee plus 302 sats of dust top-up.
What the covenant deliberately does not check
It does not pick the recipient. The pool only enforces its own side: shape, cap, and the fee coming back. Who gets paid is bound by the sender's own signature, SIGHASH_ALL|FORKID|UTXOS (0x61), over input 0. The app asks the wallet to sign only that input over WizardConnect, then verifies the signed transaction on the BCH VM before broadcasting it.
Two senders, one lane
A lane's change can be spent again before it confirms, so two people can grab the same lane at once. The second broadcast fails with txn-mempool-conflict. The app then picks another random open lane and asks the wallet for one more signature with the same coin, at most twice. Reusing the same coin matters: only one version of your payment can ever confirm.
Honest limits
- One lane is funded today; 20 is the target. Concurrency is real but thin.
- The first mainnet send was signed by a headless test key through the app's own builder and VM check, not by a named wallet. Whether a given wallet accepts a request to sign one input with sighash 0x61 is exactly what the in-app wallet gate records; none is verified yet.
- "No spendable BCH" is not "zero BCH": a token coin always carries a few hundred sats of dust.
- The fee is fixed at deploy, not oracle-priced. The covenant bounds each send, not the pool's total.
Try it
Open feepass.edycu.dev, connect a WizardConnect wallet, claim 0.25 starter PUSD if you have none, and send 0.10 PUSD. The ticket shows your spendable BCH before and after, read from the chain. Judges and the curious can start at the 60-second page.
Code, tests (189 unit and covenant VM tests, 32 end-to-end) and every mainnet txid: github.com/edycutjong/feepass.