Security & compliance

Other people’s money deserves boring certainty.

DDXPay is built so that the dangerous mistakes of a payment platform — counting a deposit twice, leaking data between clients, letting a test touch live funds — are prevented by the structure of the system and checked on every build, not left to care.

Regulatory position

Software first. Compliance as configuration.

DDXPay is sold worldwide, and every client works under its own rules. So the question we answer is not where we are, but what the software must be able to do for you to meet your obligations where you are.

Non-custodial by default

In the default model DDXPay is technology: it orchestrates payments through your own custodian account or your own addresses and does not hold your funds or private keys. That is a property of the architecture, not only of the contract.

The EU as the engineering standard

Full Travel Rule data, screening of every deposit and an audit record of every decision are built to the level of the strictest regime. A capability that does not exist cannot be configured; one that exists can be tuned down.

Rules are versioned configuration

Risk thresholds and the Travel Rule limit live in a jurisdiction profile per merchant. Changing it issues a new version, and every decision records the version that judged it. Thresholds are never constants in the code.

Two things are not configurable

Sanctions screening is the same for everyone and cannot be switched off. And funds frozen by a stablecoin issuer are a state of the ledger, so balances never pretend that money is spendable when it is not.

This describes what the software can do. Which permissions or registrations your business needs is a question for your legal counsel, for your specific case.

Isolation

Three independent walls between clients.

A leak between tenants is fatal for a payment platform, so isolation does not depend on any one layer remembering to filter.

01

Query filters

Every query is filtered by tenant, merchant and mode by default, and the filter fails closed when the context is missing.

02

Row-level security

PostgreSQL itself refuses rows of another tenant or another mode. The application connects with an unprivileged role that cannot bypass it.

03

A test per table

Every table that holds client data has an isolation test for tenant and for mode — the build fails without one, and the database is asked directly whether isolation is on.

Test mode is a second axis, not a second copy

The mode comes from the API key or the session — never from the request body. A test session cannot be given a live adapter; an architecture test fails the build if anyone wires one.

The back office is just another client

The back office talks to the same public API as any integrator, through the same permissions and the same isolation — there is no side door for our own screens.

Money integrity

Nothing counted twice. Nothing deleted.

Blockchains and webhooks deliver the same event more than once as a matter of course. The platform is built for that.

  • Exactly-once in the database. A chain transfer is recorded once per chain, transaction and log index — enforced by a unique index, not by hoping the code is careful.
  • Reorganisations handled. Confirmations scale with the amount; if a block disappears after a credit, a compensating entry reverses it. Debt that results is shown as debt.
  • A double-entry, append-only ledger. Unbalanced transactions cannot be written; corrections are mirror entries.
  • Free and total balances. Everything that spends checks the free balance, so two approvals cannot spend the same hundred.
  • Reconciliation without tolerance. Book balances are compared with the custodian’s, and a custodian that does not answer is an alarm, not a match.
  • Idempotency on every write, so a retried request cannot create a second payment or payout.

Access

Least privilege, enforced both ways.

Every operation names the permission it needs, and every endpoint checks it — a build fails if one does not.

  • Roles built from permissions — Operator, Approver, Compliance officer, Manager, Observer, Administrator — and the menu shows only what a session can reach.
  • Nobody grants what they do not have: not to a person, not to an API key. A narrower account cannot suspend or take over a wider one.
  • Four eyes on outgoing money, plus an address allowlist with a cooling-off period and limits per asset.
  • Two-factor sign-in with one-time recovery codes; an administrator can reset a password but never remove someone’s second factor.
  • Sessions you can see and end — per device, immediately. Suspending a person or changing their rights ends their sessions.
  • Rate limits per tenant and per mode.

Secrets, audit & data

What we keep, how, and who can see it.

Secrets

  • Never in code, logs or responses
  • Recoverable secrets encrypted with AES-GCM
  • API keys stored only as hashes
  • Screens show the last four characters

Audit trail

  • Append-only by database privilege
  • Who, what, when, which key, which mode
  • Refused attempts recorded too
  • Searchable from the back office

Personal data

  • Collected only where compliance needs it
  • No personal or financial data in logs
  • Device names, not raw user agents or IPs, on sessions
  • Hidden from AI models unless you allow it

AI safety

An assistant with a person in the loop.

Data from a blockchain, an e-mail or a document can try to instruct a model. So the model never acts alone where it matters.

  • Reads run automatically; writes wait for a person, who sees the exact operation and arguments before confirming.
  • The agent has the rights of the person or key it works for — never more — and every call is checked again against your AI settings.
  • Operations that carry secrets are excluded from the agent by design, not by setting.
  • Personal data is masked by category before it reaches the model; the shape stays, the values do not.
  • Everything is off by default, and the platform operator can cap what any tenant may enable.

Engineering

The rules are tests, not intentions.

Every change goes through an automated gate before it ships: thousands of unit, integration, API and browser tests against a real PostgreSQL database, and architecture tests that turn the rules on this page into build failures.

Every operation is tested

An operation without a test, a command without a validator or an endpoint without authorisation fails the build.

Every boundary is checked

Modules cannot reach into each other’s tables, migrations must match the model, and the public API must stay backward compatible.

Providers behind ports

Custodians, chains, risk scoring, rates, exchanges and messaging are adapters behind interfaces — replaceable without touching the core, and simulated in test mode.

Bring your compliance team.

We are happy to go through the controls with the people who will answer for them.