[bitcoin-dev] Conjectures on solving the high interactivity issue in payment pools and channel factories

[Antoine Riard]

Hi,

This post recalls the noticeable interactivity issue encumbering payment
pools and channel factories in the context of a high number of
participants, describes how the problem can be understood and proposes few
solutions with diverse trust-minizations and efficiency assumptions. It is
intended to capture the theoretical bounds of the "interactivity issue",
where technical completeness of the solutions is exposed in future works.

The post assumes a familiarity with the CoinPool paper concepts and
terminology [0].

# The interactivity requirement grieving payment pools/channel factories

Payment pools and channel factories are multi-party constructions enabling
to share the ownership of a single on-chain UTXO among many
off-chain/promised balances. Payment pool improves on the channel factory
construction fault-tolerance by reducing the number of balance outputs
disclosed  on-chain to a single one in case of unilateral user exits.

However, those constructions require all the users to be online and
exchange rounds of signatures to update the balance distribution. Those
liveliness/interactivity requirements are increasing with the number of
users, as there are higher odds of *one* lazzy/buggy/offline user stalling
the pool/factory updates.

In echo, the design of LN was envisioned for a network of
always-online/self-hosted participants, the early deployment of LN showed
the resort to delegated channel hosting solutions, relieving users from the
liveliness requirement. While the trust trade-offs of those solutions are
significant, they answer the reality of a world made of unreliable networks
and mobile devices.

Minding that observation, the attractiveness of pools/factories might be
questioned.

# The interactivity requirement palliatives and their limits

Relatively straightforward solutions to lower the interactivity
requirement, or its encumbered costs, can be drawn out. Pools/factories
users could own (absolute) timelocked kick-out abilities to evict offline
users who are not present before expiration.

E.g, let's say you have Alice, Bob, Caroll and Dave as pool participants.
Each of them owns a Withdraw transaction to exit their individual balances
at any time. Each user should have received the pre-signed components from
the others guaranteeing the unilateral ability to publish the Withdraw.

A kick-out ability playable by any pool user could be provided by
generating a second set of Withdraw transactions, with the difference of
the nLocktime field setup to an absolute height T + X, where T is the
height at which the corresponding Update transaction is generated and X the
kick-out delay.  For this set of kick-out transactions, the complete
witnesses should be fully shared among Alice, Bob, Caroll and Dave. That
way, if Caroll is unresponsive to move the pool state forward after X, any
one of Alice, Bob or Dave can publish the Caroll kick-out Withdraw
transaction, and pursue operations without that unresponsive party.

While decreasing the interactivity requirement to the timelock delay, this
solution is constraining the kicked user to fallback on-chain encumbering
the UTXO set with one more entry.

Another solution could be to assume the widespread usage of node towers
among the pool participants. Those towers would host the full logic and key
state necessary to receive an update request and produce a user's approval
of it. As long as one tower instance is online per-user, the pool/factory
can move forward. Yet this is forcing the pool/factory user to share their
key materials with potentially lower trusted entities, if they don't
self-host the tower instances.

Ideally, I think we would like a trust-minimized solution enabling
non-interactive, off-chain updates of the pool/factory, with no or minimal
consumption of blockspace.

For the remainder of this post, only the pool use-case will be mentioned.
Though, I think the observations/implications can be extended to factories
as well.

# Non-interactive Off-chain Pool Partitions

If a pool update fails because of lack of online unanimity, a partition
request could be exchanged among the online subset of users ("the
actives"). They decide to partition the pool by introducing a new layer of
transactions gathering the promised/off-chain outputs of the actives. The
set of outputs belonging to the passive users remains unchanged.

The actives spend their Withdraw transactions `user_balance` outputs back
to a new intermediate Update transaction. This "intermediate" Update
transaction is free to re-distribute the pool balances among the active
users. To guarantee the unilateral withdraw ability of a partitioned-up
balance, the private components of the partitioned Withdraw transactions
should be revealed among the set of active users.

E.g, let's say you have Alice, Bob, Caroll and Dave as pool participants.
Pool is at state N, Bob and Dave are offline. Alice and Caroll agree to
partition the pool, each of them owns a Withdraw transaction
ready-to-be-attached on the Update transaction N. They generate a new
partitioning Update transaction with two inputs spending respectively
Alice's Withdraw transaction `user_balance` output and Caroll's Withdraw
transaction `user-balance` output. From this partitioning Update
transaction, two new second-layer Withdraw ones are issued.

Alice and Caroll reveal to each other the private components of their
first-layer Withdraw transactions, allowing to publish the full branch :
first-layer Update transaction, first-layer Withdraw transactions,
second-layer partitioning Update transaction, second-layer partitioned
Withdraw transaction. At that step, I think the partitioning should be
complete.

Quickly, a safety issue arises with pool partitioning. A participant of the
active set A could equivocate the partition state by signing another spend
of her Withdraw transaction allocating her balance to an Update transaction
of a "covert" set of active users B.

This equivocation exists because there is no ordering of the off-chain
spend of the Withdraw transactions and any Withdraw transaction can be
freely spent by its owner. This issue appears as similar to solving the
double-spend problem.

Equivocation is a different case than multiple *parallel* partitions, where
there is no intersection between the partitioned balances. The parallel
partitions are still rooting from the same Update transaction N. I think
the safety of parallel partitions is yet to be explored.

# Current solutions to the double-spend problem : Bitcoin base-layer &
Lightning Network

Of course, the double-spend issue is already addressed on the Bitcoin
base-layer due to nodes consensus convergence on the most-proof-of-work
accumulated valid chain of blocks. While reorg can happen, a UTXO cannot be
spent twice on the same chain. This security model can be said to be
prophylactic, i.e an invalid block cannot be applied to a node's state and
should be rejected.

The double-spend issue is also solved in its own way in payment channels.
If a transaction is published, of which the correctness has been revoked
w.r.t negotiated, private channel state, the wronged channel users must
react in consequence. This security model can be said to be corrective,
states updates are applied first on the global ledger then eventually
corrected.

A solution to the pool partition equivocation issue appears as either based
on a prophylactic one or a corrective security model.

Let's examine first, a reactive security model similar to LN-Penalty. At
pool partition proposals, the owners of the partitioned-up Withdraw
transactions could reveal a revocation secret enabling correction in case
of wrongdoing (e.g single-show signatures). However, such off-chain
revocation can be committed towards multiple sets of honest "active" users.
Only one equivocating balance spend can succeed, letting the remaining set
of honest users still be deprived of their expected partitioned balances.

E.g, let's say you have Alice, Bob, Caroll and Dave as pool participants.
Alice contacts Bob to form a first partition, then Caroll to form a second
one, then Dave to form a last one. If she is successful in that
equivocation trick, she can *triple*-spend her balance against any goods or
out-of-pool payments.

Assuming the equivocation is discovered once realized, Bob, Caroll and Dave
are all left with a branch of transactions all including Alice's Withdraw
one. However only one branch can be fully published, as a Withdraw
transaction can be played only once following the pool semantic.
Game-theory-wise, Bob, Caroll and Dave have an interest to enter in a fee
race to be the first to confirm and earn the Alice balance spend.

The equivocation is only bounded by the maximal number of equivocating sets
one can form, namely the number of pool users. However, correction can only
be limited to the equivocated balance. Therefore, it appears that
corrective security models in the context of multi-party are always
producing an economic disequilibrium.

An extension of this corrective model could be to require off-pool
collaterals locked-up, against which the revocation secret would be
revealed at partition generation. However, this fix is limited to the
collateral liquidity available. One collateral balance should be guaranteed
for each potential victim, thus the collateral liquidity should be equal to
the number of pool users multiplied by the equivocatable balance amount.

It sounds like a more economic-efficient security model of the pool
partitioning can be established with a prophylactic technique.

# Trusted coordinator

A genuine solution could be to rely on a coordinator collecting the
partition declaration and order them canonically. The pool partition
candidates can then fetch them and decide their partitions acceptance
decisions on that. Of course, the coordinator is trusted and can drop or
dissimulate any partition, thus enabling partitioned balance equivocation.

# Trust-minimized : Partition Statements

A pool partition invalidity can be defined by the existence of two
second-layer Update transactions at the same state number spending the same
Withdraw transaction balance output. Each Update transaction signature can
be considered as a "partition statement". A user wishing to join a
partition should ensure there is no conflicting partition statement before
applying the partition to her local state.

The open question is from where the conflict should be observed. A
partition statement log could be envisioned and monitored by pool users
before to accept any partition.

I think multiple partition statement publication spaces can be drawn out,
with different trust-minization trade-offs.

# Publication space : Distributed Bulletin Boards

The set of "active" pool users could host their own boards of partition
statements. They would coordinate on the statement order through a
consensus algorithm (e.g Raft). For redundancy, a user can have multiple
board instances. If a user falls offline, they can fetch the statement
order from the other users boards.

However, while this solution distributes the trust across all the other
users, it's not safe in case of malicious user coalitions agreeing among
themselves to drop a partition statement. Therefore, a user catching up
online can be feeded with an incorrect view of the existing partitions, and
thus enter into an equivocated partition.

# Publication space : On-chain Authoritative Board

Another solution could be to designate an authoritative UTXO at pool setup.
This UTXO could be spent by any user of the pool set (1-of-N) to a
covenanted transaction sending back to a Taproot output with the same
internal key. The Merkelized tree tweaked could be modified by the spender
to stamp the partition statements as leaves hashes. The statement data is
not committed in the leaves itself and the storage can be delegated to
out-of-band archive servers.

E.g, let's say you have Alice, Bob, Caroll and Dave as pool participants.
Alice and Bob decide to start a partition, they commit a hash of the
partitioning Update transaction as a Taproot tree leaf and they spend the
pool authoritative UTXO. They also send a copy of the Update transaction to
an archive server.

At a later time, Alice proposes to Caroll to start a partition. Caroll
follows the chain of transactions forming the on-chain authoritative board,
she fetches the merkle branches and leaves data payload from an archive
server, verifying the authenticity of the branches and payload. As Alice
has already published a partition statement spending her Withdraw, Caroll
should refuse the partition proposal.

Even if a pool user goes offline, she can recover the correct partition
statement logs, as it has been committed in the chain from the
authoritative UTXO. If the statement data is not available from servers,
the pool user should not engage in partitions.

Assuming the spend confirms in every block, this solution enables
partitions every 10min. The cost can be shared across pool instances, if
the authoritative signers set is made of multiple pool instances signers
sets. A threshold signature scheme could be used to avoid interactivity
beyond the aggregated key setup. However, batching across pool instances
increases the set of data to verify by the partition candidate users, which
could be a grievance for bandwidth-constrained clients.

# Fiability of the Publication of Partition Statements

Whatever ends up being used as a partition statement log, there is still
the question of the incentives of pool users to publish the partition
statements. A malicious user could act in coalition with the equivocating
entity to retain the publication of her partition statement. Thus, an
honest user would only be aware of her own partition statement and accept
the partition proposal from the will-be equivocating entity.

I think that leveraging covenants a revocation mechanism could be attached
on any equivocating branch of transactions, allowing in the above case a
single honest user to punish the publication. While a revocation mechanism
does not work in case of multiple defrauded users, I believe the existence
of a revocation mechanism makes the formation of malicious coalitions
unsafe for their conjurers.

Indeed, any user entering in the coalition is not guaranteed to be blinded
to other equivocating branches generated by the partition initiator.
Therefore, the publication of a partition statement by everyone is
holistically optimal to discover any equivocating candidate among the pool
users.

Further research should establish the soundness of the partition statement
publication game-theory.

# Writing the Partition Statements to a new Consensus Data Structure

To avoid a solution relying on game-theory, a new consensus data structure
could be introduced to register and order the partition statements. This
off-chain contract register could be a Merkle tree, where every leaf is a
pool balance identified by a key. This register would be established
on-chain at the same time the pool is set up.

Every time the pool is partitioned, the tree leaves would be updated with
the partition statement committed to. Only one partition could be
registered per user by state number. The publication branch would be
invalid if it doesn't point back to the corresponding contract register
tree entries. When the first-layer pool Update transaction is replaced, the
tree should transition to a blank state too.

Beyond the high cost of yet-another softfork to introduce such consensus
data structure, the size of the witness to write into the contract register
could be so significant that the economic attractiveness of pool
partitioning is decreased in consequence.

If you have read so far, thank you. And curious if anyone has more ideas or
thoughts on  the high interactivity issue ?

Thanks Gleb for the review.

Cheers,
Antoine

[0] https://coinpool.dev/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.linuxfoundation.org/pipermail/bitcoin-dev/attachments/20220428/6ceb610b/attachment-0001.html>