Skip to content
MaatX

Blockchain systems beyond the smart contract.

The contract is one layer. Most of what decides whether a blockchain system survives production lives in the indexing, the risk model and the reconciliation nobody demos.

Every layer, not one.

A reorg that corrupts indexed balances, an oracle that goes stale mid-move, a retry that submits twice. None of those are contract bugs.

  1. 01

    Smart contracts

    Audited, role-gated, upgrade-aware on-chain logic with property tests.

    • Solidity
    • Foundry
    • Slither
  2. 02

    Protocols

    The economic design around the contract: incentives, parameters, failure behaviour.

    • Mechanism design
    • Simulation
  3. 03

    Indexing

    Reorg-safe cursors and deterministic rollback, so history stays correct.

    • Rust
    • ClickHouse
    • ABI decoding
  4. 04

    Data

    Entity resolution, flow aggregation and analytics over raw chain events.

    • Columnar store
    • Graph store
  5. 05

    APIs

    Idempotent mutations, request signing and typed clients over it all.

    • Node.js
    • REST
    • Webhooks
  6. 06

    Risk

    Collateral health, oracle staleness and concentration limits, evaluated continuously.

    • Risk engine
    • Policy as config
  7. 07

    Reconciliation

    A double-entry ledger that is authoritative, with breaks raised as exceptions.

    • PostgreSQL
    • Double-entry
  8. 08

    Applications

    The product a person actually uses, with every failure state designed.

    • Next.js
    • React
    • TypeScript

What we build on-chain.

Each of these is a different system with different failure modes, not a variation of one template.

PREDICT, prediction market infrastructure — product interface

Prediction market

Markets that price meaningfully and settle mechanically.

Demonstrated in

PREDICT

Also in scope

  • DEX

    Order books, AMMs and routing with real depth.

  • Token

    Supply, vesting and transfer rules that hold up.

  • NFT

    Collections, ownership and marketplace mechanics.

  • Wallet

    Key management, signing and recovery flows.

  • Launchpad

    Issuance, allocation and vesting under policy.

  • DAO

    Proposals, voting, timelocks and execution.

  • Infrastructure

    RPC routing, indexers and event delivery guarantees.

Where blockchain systems actually fail.

These are the problems we design for first, because retrofitting them is expensive.

01

Reorgs corrupt indexed state

Indexers write against a confirmed cursor with a deterministic rollback, so a reorg is a handled event with an affected range — not silent data loss.

02

Oracle failure is a solvency event

Feeds are checked for deviation and staleness before entering a risk model. On breach the engine holds last-known-good and blocks new leverage.

03

Retries submit transactions twice

Every mutation carries an idempotency key and moves through an explicit state machine with replacement and cancellation paths.

04

Balances read from the chain are already wrong

A double-entry ledger with enforced invariants is authoritative. Chain state is an input to it, never the number a user sees.

05

Eligibility changes but contracts do not

Transfer restrictions call a registry at transfer time, so a lapsed accreditation blocks a transfer without redeploying anything.

What it costs, and what you are agreeing to.

The commercial answers in one place, so none of them has to wait for a call.

Typical route in

Mechanism & Architecture

From $4,500

1–3 weeks

We take the mechanism apart before anyone estimates it. You leave with an architecture you could hand to any competent team, the economic failure modes named, and an honest list of what is likely to go wrong.

A starting point for the scope described, not an estimate for your project. Ongoing engineering runs at $75 per hour blended.

Who owns what you build?

You do. On full payment of the fees for an engagement, the intellectual property in everything built specifically for you is assigned to you.

Our pre-existing tools, libraries and internal infrastructure stay ours — but where a deliverable uses them, you get a perpetual, worldwide licence to run, modify and extend it. Nothing we hand over needs us to keep operating it. Open-source and third-party components keep their own licences, and we tell you which ones and what they require.

We also will not name you as a client, describe your project, or publish a case study about it without your written agreement.

What happens if it does not work out?

Either of us can end an engagement with 30 days written notice, or immediately if the other commits a material breach and does not remedy it within 15 days. You pay for work properly performed up to that point, and we hand over completed work along with every deliverable you have paid for.

Two limits worth stating before you ask. We are engineers, not advisers: nothing we deliver is legal, regulatory, tax or financial advice, and a system built to your specification is not an opinion that it is lawful in your jurisdiction. And where our work includes reviewing or auditing code, the findings cover the scope and time agreed — an absence of findings is not a guarantee that nothing is there.

What do you need from me to start?

Not a specification. Discovery exists precisely because most people do not have one — an idea, or a technical problem you cannot yet size, is enough to begin.

What the work does assume: timely access to the people, systems, credentials and environments it touches; decisions and approvals at roughly the pace the timeline assumes, since delays on your side move both dates and cost; and that you have the right to give us whatever you give us, including data, code and third-party material.

Why you rather than the alternative?

Against hiring a senior engineer in-house: sourcing one takes months and commits you permanently. Discovery runs 1–3 weeks, and you keep the architecture whichever way you then go — including if the answer is to make that hire.

Against the cheapest contractor available: you will pay less per hour. Our argument is that the architecture decision is the one that is expensive to reverse, which is why we sell it first, separately, and at a price you can say yes to before committing to a build.

Against a larger firm: there is no account layer. The people who scope the work are the people who build it.

And when not to hire us: if a no-code or off-the-shelf tool still fits what you are doing, stay on it. We are worth paying once you have hit a ceiling you cannot engineer around from where you are.

These are summaries. The binding version of the ownership, exit and liability terms is in our Terms of Service. A person reads every enquiry. We usually reply within a few hours.

Start a technical assessment

Building something on-chain?

Bring us the protocol, the product or the problem. We’ll help define the architecture and the path to production.