Launch recurring payment streams on Canton without rebuilding lifecycle plumbing.
OpenFluid gives builders reusable Daml contracts, a generated TypeScript SDK, and a read layer for stream state, balances, lifecycle actions, and product integration.
Payroll demo · Subscription demo · Daml contracts · Generated TypeScript SDK · Canton JSON API read layer
Create, pause, resume, top up, cancel, and settle one shared stream path.
Generated from the Daml model into TypeScript types for product code.
Direct Canton JSON API reads for balances and live state.
The missing primitive in Canton payment apps
Canton gives teams a strong base for private, programmable workflows. OpenFluid removes the recurring-payment lifecycle plumbing so builders do not have to rebuild state, actions, and reads for every launch.
Stream contract logic, lifecycle actions, read models, operator permissions, and the glue between ledger state and the product UI.
Ledger and UI drift
The app says active while the ledger is paused.
Funding gaps
Top-ups land late and the stream runs dry.
Stale cancellations
A cancelled stream still shows up as live.
Manual support
Ops teams check logs, Slack, and spreadsheets for basic state.
Ticket churn
Every edge case becomes a one-off fix.
Define the stream once, then reuse it everywhere
OpenFluid keeps the recurring-payment lifecycle in one place so Canton builders can ship faster, read cleaner, and avoid duplicate state logic across products.
Choose sender, recipient, asset, rate, buffer, and permissions once.
Create, pause, resume, top up, cancel, settle, and monitor from the same contract state.
Expose balances, accrued value, status, and operator views through the app layer.
Apply the same stream model to payroll, billing, grants, vesting, and controlled release.
What OpenFluid includes
Contracts, SDK, read layer, and reference apps. One reusable stream lifecycle instead of a one-off integration for every product surface.
Contracts
Daml templates for stream agreements, lifecycle actions, distribution pools, conditional streams, and vault-backed release.
SDK
Generated TypeScript integration layer for creating, reading, and operating streams from product code.
Read layer
App-facing routes and read models for balances, status, lifecycle state, and operator views.
Reference apps
Payroll and subscription demos showing the same primitive reused across payout and billing flows.
The contract surface behind OpenFluid
StreamToken, StreamAgreement, DistributionPool, ConditionalStream, StreamVault, and policy hooks give Canton builders a reusable recurring-payment layer.
StreamAgreement
Core two-party contract for sender, recipient, asset, rate, buffer, and lifecycle actions.
StreamToken
CIP-56-compatible wrapper that makes a Canton asset streamable.
DistributionPool
One sender, many recipients for payroll, revenue share, and batch payout.
ConditionalStream
Milestone-gated or oracle-conditioned release with programmable triggers.
StreamVault
Escrow-backed release for vesting, grants, and treasury-controlled unlocks.
Policy hooks
Optional allowlists, operator controls, and external checks for teams that need them.
Proof in the stack
The payroll and subscription surfaces use the same primitive, the same lifecycle logic, and the same read layer. That keeps the launch story honest and the implementation surface small.
Payroll and billing do not need separate lifecycle layers. OpenFluid keeps the same stream state visible to the app, the operator, and the read layer.
Shared lifecycle model
Both demos use the same contract and read model shape.
Payment workflows OpenFluid supports
The same primitive covers payroll, subscriptions, grants, vesting, revenue sharing, and treasury-controlled release on one reusable rail.
Primary workflows
The first jobs teams ship on OpenFluid.
Distribution pools keep recurring compensation moving from treasury to named recipients.
Access stays active while the stream is active, and closes cleanly when it is not.
Expansion workflows
Same primitive, broader money flows.
Conditional streams release funds only when milestones are approved.
Vault-backed release for cliff or linear unlocks.
Split recurring value between multiple recipients.
Operator-controlled disbursement for schedules, approvals, and payout policy.
Build against one stream lifecycle
OpenFluid keeps the product surface clear while the implementation details stay visible to builders who need them. Architecture, SDK design, indexer design, and security notes live in the repo for the teams integrating it.
await openfluid.streams.create({
sender: treasuryParty,
recipient: contractorParty,
asset: paymentAsset,
ratePerSecond: '0.00145',
bufferAmount: '500',
operator: opsParty,
})
await openfluid.streams.pause(streamId)
await openfluid.streams.topUp(streamId, '250')
await openfluid.streams.resume(streamId)
await openfluid.streams.settle(streamId)- Daml contract primitives
- Generated TypeScript SDK path
- Canton JSON API read layer
- Payroll demo
- Subscription demo
- Independent audit
- Hardened operator controls
- Production monitoring
- Release process
- Expanded policy hook docs
Request pilot access
Tell us what recurring payment workflow you are building on Canton. We will map it to the right OpenFluid primitive, demo path, and integration surface.
Pilots, product demos, and ecosystem partnerships.