Blockchain Systems

On-chain systems combine the permanence of infrastructure with the exposure of a public API. We keep contracts small, push complexity into off-chain services we can upgrade and monitor, and design the operational layer of custody, compliance and reconciliation with the same care as the code.

Capabilities

Smart contract development

Solidity and Rust contracts written for clarity and auditability, with property-based and invariant testing.

Stablecoin and payment systems

Issuance, settlement, treasury and payout flows, with reconciliation against off-chain ledgers.

Tokenisation platforms

Tokenised funds, credit and real-world assets, with transfer restrictions and investor registries.

Wallet and custody infrastructure

MPC and multi-signature signing services, key ceremonies, policy engines and recovery procedures.

Cross-chain systems

Bridging and messaging designs that make trust assumptions explicit and limit the impact of any failure.

Indexing and on-chain data

Event indexers and data pipelines that bring on-chain activity into reporting and risk systems.

Reference architecture

Interfaces
  • Operator console
  • Client portal
  • Settlement API
Off-chain services
  • Compliance engine (core component)
  • Signing service (core component)
  • Indexer
  • Reconciliation
Contracts
  • Token
  • Settlement (core component)
  • Access control
  • Upgrade governance
Networks
  • Ethereum and L2s
  • Solana
  • Permissioned networks
Assurance
  • Invariant tests (core component)
  • External audit
  • Runtime monitoring
  • Incident runbooks
Reference architecture for an institutional settlement system. Most of the system lives off-chain.

Zero to one

Taking an organisation on-chain for the first time.

No wallets, no contracts and no certainty yet that a blockchain is the right tool. We start by answering that honestly. If it is, we design the smallest on-chain footprint that delivers the benefit, with custody, compliance and accounting worked out before anything ships.

Nothing in place yet is a normal place to start. It does not limit what we can build.

  1. Step 1

    Test the fit

    Decide whether on-chain infrastructure is right for the problem, and say so if it is not.

  2. Step 2

    Choose the foundations

    Networks, custody model, compliance approach and accounting treatment.

  3. Step 3

    Build a minimal first product

    Small contracts, audited, with the off-chain services around them.

  4. Step 4

    Set up operations

    Monitoring, reconciliation, key management and incident runbooks.

Problems we are brought in to solve

A token without the operations around it

We design the issuance, redemption, compliance and reconciliation workflows that surround the contract, because that is where most of the work and most of the risk sit.

Settlement that depends on manual steps

We build settlement services that confirm on-chain finality, reconcile against internal ledgers and raise exceptions to operators instead of relying on spreadsheets.

Keys held by people, not policy

We implement signing infrastructure with quorum policies, transaction simulation and clear recovery procedures.

Engineering standards

  • Contracts do as little as possible, and nothing is upgradeable by accident.

  • Invariants are written before features and enforced in tests.

  • Every privileged action has a named owner, a quorum and a log.

  • On-chain state is reconciled with off-chain records continuously.