Ryvo supports an operator hub model on top of the base protocol. In this model, users open payment channels to a hub, providers open payment channels with that same hub, and the hub handles payment flow between both sides. The hub can enforce its own pricing, compliance, and routing logic, while settlement still happens through Ryvo’s protocol state.Documentation Index
Fetch the complete documentation index at: https://docs.ryvo.network/llms.txt
Use this file to discover all available pages before exploring further.
The shape
Instead of every user opening a direct channel to every provider, the payment graph looks like this:How a hub works
The hub becomes the party that:- receives signed payment updates from users
- decides whether to honor or reject a request
- serves the request directly or forwards it to a provider
- signs outbound payment updates to providers
- settles both sides later through normal Ryvo settlement
Why it fits Ryvo
Ryvo does not do Lightning-style multi-hop routing. It does have the primitives that a hub needs:- permanent participant identities
- permanent one-way payment channels
- cumulative commitments
- payee-side bundle settlement
- cooperative clearing when several participants want to co-sign one shared update
Worked example
Alice wants to pay an RPC provider through a hub.- Alice has a channel to the hub.
- The provider has a channel from the hub.
- Alice signs a cumulative commitment increasing what she owes the hub.
- The hub checks Alice’s balance, channel lock, policy rules, and rate limits.
- The hub serves the RPC call (or forwards it to the provider).
- The hub signs a cumulative commitment increasing what it owes the provider.
- Later, the hub settles inbound and outbound channels through normal Ryvo settlement.
Operating models
Guaranteed-capacity
If the spending side locks enough funds to the channel, the receiving side has guaranteed payment capacity on that relationship. The hub operates the service layer, but it does not need off-chain custody to make the payment valid.Trust-minimized
If only partial expected usage is locked, or if balances are mostly shared rather than locked per channel, the model becomes trust-minimized. The payee takes more timing and credit risk between settlements, but the protocol is still non-custodial.Credit
If the hub extends credit in either direction, the trust surface grows. Balances continue to live non-custodially in protocol state, but the hub’s business logic is now bearing risk and liquidity exposure.What the hub controls (and what it does not)
A hub can still control service access. It can:- deny service
- delay forwarding
- require additional lockup
- choose which providers it will work with
Operator payment is separate
A hub is an economic participant like any other. If a hub should be paid, that payment should be modeled as its own ordinary channel commitment, typically:payer → hubfor accesshub → providerfor fulfillment
Why this is different from a single managed rail
At the product layer, a hub can look similar to a centralized micropayment rail:- one operator coordinates payment flow
- one operator can gate access or apply policy
- users and providers do not need a full mesh of direct channels
- Any team can build a hub on top of the protocol.
- Users and providers are not bound to one payment company just to access the settlement rail.
- Multiple hubs can coexist and compete, or a team can bypass hubs entirely with direct channels.
