Platform

A small kernel between the decision to pay and the wallet.

Everything the app, the API and the SDK do goes through the same five steps. That is what lets one payout be approved by people, sent once, checked when in doubt, and proven afterwards.

  • Real Lightning verified on regtest
  • Mainnet disabled
  • Not audited

How it fits together.

One Node.js API process serves this site at /, the app at /app and the API at /v1, backed by PostgreSQL. Multi-instance operation has not been verified.

Surfaces

  • Web app at /app
  • REST API at /v1, described by OpenAPI
  • TypeScript SDK (in the repository, not on npm)
  • Signed webhooks
  • Offline verifier CLI

Workspace services

  • Accounts, workspaces, roles, invitations, TOTP
  • Plans and server-enforced entitlements
  • Billing through a provider abstraction
  • Support requests
  • Counts-only product analytics

Kernel

  1. Obligation
  2. Authorization
  3. Execution
  4. Reconciliation
  5. Evidence

Wallet adapters

  • LND over REST: Verified · regtest
  • Practice wallet (simulator): labelled, never a real receipt
  • NWC, BTCPay, Core Lightning: Not built

Storage and evidence

  • PostgreSQL, with versioned migrations
  • Hash-chained audit streams (tamper-evident, not immutable)
  • Ed25519-signed receipts

Orynt never holds funds. The wallet holds the money; its credentials decide what Orynt could do with it. See integrations and who enforces what.

What each step does.

Step 1 of 5

Obligation Verified · real regtest

Write down the payout before anything moves.

A payout is a record: payee, exact amount in whole millisatoshis, memo, your own reference, and a Lightning invoice that Orynt decodes and checks (signature, network, amount, expiry, payee node key). Edits never overwrite: each is a new immutable revision. Batches (a CSV of up to 200 rows) and recurring schedules do not bypass this step; they only create ordinary payouts.

Features

  • Payee records, optionally bound to a node key
  • Lightning Address resolved to a checked invoice
  • Invoice decoding and binding
  • Immutable revisions
  • Plan limits checked on the server when a payout is created
  • Batch CSV import with per-row validation
  • Recurring schedules (each cycle asks for a fresh invoice)

API surface

  • POST /v1/obligations
  • PUT /v1/obligations/:id
  • POST /v1/lnurl/resolve
  • POST /v1/batches
  • POST /v1/schedules

Step 2 of 5

Authorization Verified · simulator + tests

The right people approve the exact payout, with signatures.

Submitting freezes a revision and binds the active policy. Each approver signs the intent digest, a fingerprint of the exact payout, with an Ed25519 key kept in their browser. Changing the payout or the policy voids earlier approvals. Roles are checked at approval and again at execution; API keys can never approve.

Features

  • Policy revisions (approvals needed, maker-checker, thresholds)
  • Ed25519 signed approvals
  • Role and permission checks
  • TOTP two-factor step-up (sign-in, approve, execute)
  • Team invitations

API surface

  • POST /v1/obligations/:id/submit
  • POST /v1/obligations/:id/approve
  • POST /v1/policies
  • POST /v1/me/approval-key

Step 3 of 5

Execution Verified · real regtest

An approved payout is sent exactly once.

Before the wallet is called, a single-use execution record is reserved. A second send is refused while the first is unresolved, and the request needs an Idempotency-Key. Mainnet execution is switched off.

Features

  • Single-use execution reservation
  • Idempotency keys
  • Wallet capability check
  • Mainnet disabled

API surface

  • POST /v1/obligations/:id/execute
  • POST /v1/batches/:id/execute

Step 4 of 5

Reconciliation Verified · real regtest

When the answer is lost, ask the wallet. Do not guess.

If the wallet does not answer, the payout becomes UNKNOWN, then RECONCILING. Orynt asks the wallet for its own record by payment hash. Only that record moves the payout to SETTLED or DEFINITIVELY_FAILED; an expired invoice alone proves nothing. Unresolved cases open an incident with notes and an owner, and a person can attest, with fresh evidence, that nothing was sent.

Features

  • UNKNOWN and RECONCILING states
  • Lookup by payment hash
  • Incident workbench (notes, assignment)
  • Attested “confirm not sent”
  • Retry only after proven failure
  • Startup recovery of stuck payments

API surface

  • POST /v1/payments/:id/reconcile
  • POST /v1/payments/:id/confirm-not-sent
  • POST /v1/payments/:id/retry
  • POST /v1/incidents/:id/resolve

Step 5 of 5

Evidence Verified · real regtest

Proof anyone can check without trusting us.

A settled payment can produce a signed receipt that binds the agreement, the signed approvals and the wallet's result, including the preimage whose hash is the payment hash. A separate command-line verifier checks it offline. The audit log is hash-chained, and reports can be exported as CSV.

Features

  • Signed receipts (orynt.receipt/1)
  • Offline verifier CLI
  • Hash-chained audit log
  • Payout reports and per-recipient statements
  • Signed webhooks for your own systems

API surface

  • GET /v1/payments/:id/receipt
  • GET /v1/audit/verify
  • GET /v1/reports/payouts
  • POST /v1/webhooks

What has been checked, and how.

“Verified” follows the project's execution register: a command was run in this environment and its result recorded. Source: docs/EXECUTION-REGISTER.md.

Verification evidence per kernel step
StepStatusEvidence
ObligationVerified · real regtestInvoice decoder checked against spec vectors and against invoices from a real LND node; Lightning Address resolution checked against a local LNURL test server on regtest.
AuthorizationVerified · simulator + testsAdversarial and security-regression suites on PostgreSQL: stale, duplicate, revoked-role and wrong-tenant approvals are refused.
ExecutionVerified · real regtestOn a real regtest node, 10 concurrent executes produced 1 payment. A simulator load run of 100 payouts with 3 concurrent executes each gave 100 sends and 0 doubles (not a capacity claim).
ReconciliationVerified · real regtestReal regtest demo: the API was killed with SIGKILL after LND accepted the payment; after restart the payout was UNKNOWN, was reconciled, and settled once.
EvidenceVerified · real regtestReceipts from the real regtest demo verify (exit 0); tampered, replayed and substituted receipts are rejected. 26 verifier tests.

Limits of that evidence.

  • Real Lightning runs are on Bitcoin regtest, a private test network with no monetary value. Mainnet is disabled.
  • Checks are automated tests and scripted demos. There is no human security audit or penetration test, and no manual screen-reader testing.
  • Approval rules live in Orynt, not in the wallet. Someone holding your wallet credentials can bypass them.

Rules the kernel does not bend.

  • Amounts are integer millisatoshis, never decimals.
  • A payout's terms cannot change after approval without voiding the approval.
  • No payout can be sent twice; a second send is refused while the first is unresolved.
  • “Failed” only ever means the wallet's own record proves it.
  • Simulated payments are labelled everywhere and can never produce a real receipt.
  • A recurring schedule never pays by itself. It opens a task asking for a new invoice; the payout then goes through approval like any other.
  • Reports sum only real settlements and carry no fiat values.
  • Plan limits are checked on the server, not just hidden in the interface.
  • Webhooks and billing events are signed, time-stamped and de-duplicated. Receipts are signed.

See the kernel work on regtest.

Create a free account, connect the practice wallet or a regtest LND node, and walk one payout through all five steps.