Skip to content

Service · Blockchain

Smart Contract Development Services

Commission us to write, test and prepare for audit the contracts that hold your users’ assets or rules. Solidity is our main language, and the deliverable is code that a reviewer can reason about, not just code that compiles.

Solidity with Foundry or Hardhat

Fuzz and invariant tests included

Audit-ready specification pack

Deliverables

What a smart contract development engagement delivers.

01Delivered

Specification before code

A written description of every state variable, role, function and invariant, so behaviour can be checked against intent rather than against whatever the code happens to do.

02Delivered

Contracts in Solidity or another fit language

Solidity on EVM chains as standard, Vyper where its simplicity helps, and Rust or Move where the target chain requires them, built on audited libraries such as OpenZeppelin where suitable.

03Delivered

Layered test suite

Unit tests, fuzz tests across input ranges, invariant tests that run random call sequences, and fork tests against real deployed tokens and protocols.

04Delivered

Gas and storage profile

Gas reports per function, storage layout documentation and, for upgradeable contracts, checks that a new version does not collide with existing storage slots.

05Delivered

Deployment scripts and verification

Scripted, repeatable deployments, source verification on block explorers, and role handover to multisig wallets as the final step.

Early decisions

Technical decisions we settle early in smart contract development.

01Decided

Upgradeable or immutable

Immutable contracts earn more trust but cannot be fixed; transparent or UUPS proxies can be, at the cost of admin risk and storage discipline. We decide per contract, not per project.

02Decided

Access control model

Single owner, role-based access, or governance through a timelock and multisig, matched to how much power operators should hold after launch.

03Decided

Toolchain

Foundry for fast Solidity-native tests and fuzzing, Hardhat where a TypeScript-heavy team will maintain the code, or both where each covers a gap.

04Decided

External dependencies

Which tokens, oracles and protocols the contracts call, how non-standard tokens such as fee-on-transfer ones are handled, and what happens if a dependency pauses.

05Decided

Compiler and language version

A pinned Solidity version with known behaviour, chosen with the target chain’s supported opcodes in mind, and no floating pragmas in deployed code.

06Decided

Emergency controls

Whether a pause, rate limit or circuit breaker exists, who can trigger it and how users can still withdraw while it is active.

Engagement

How a smart contract development engagement runs.

  1. 01Phase 1

    Specification and threat model

    We write the spec with you, list assets at risk, privileged roles and likely attacks such as reentrancy, price manipulation and signature replay, and agree the invariants that must always hold.

  2. 02Phase 2

    Implementation with tests alongside

    Contracts and tests grow together. Each function arrives with unit tests, and invariants are wired into fuzzing early so regressions show up immediately.

  3. 03Phase 3

    Internal review and static analysis

    Engineers who did not write the code review it line by line, and tools such as Slither flag patterns worth a second look before anyone external sees it.

  4. 04Phase 4

    Audit hand-off and fixes

    We package the spec, tests, known limitations and deployment plan for your chosen auditor, then fix findings and document how each one was resolved.

Fit

When a custom smart contract build is the right choice.

01Good fit

Contracts will hold real value

Deposits, tokens or rights will sit in the code, so failure means irreversible loss rather than a support ticket.

02Good fit

You need Solidity expertise specifically

Your app team is strong but has not shipped production Solidity, and you want that layer engineered properly.

03Good fit

An audit is booked or planned

You want code, tests and documentation that let auditors spend their time on logic rather than on understanding intent.

Write the invariants first

An invariant is a statement that must stay true whatever users do, such as total deposits equalling the sum of balances. Writing them down before coding turns vague intent into something a fuzzer can attack thousands of times per run.

Invariant tests find the bugs unit tests miss: those that appear only after an unusual sequence of calls by different accounts.

Solidity rewards boring code

Clever assembly and gas tricks make audits slower and mistakes likelier. We use well-reviewed libraries for tokens, access control and signatures, follow checks-effects-interactions, and only optimise where the gas report shows a real cost to users.

Upgradeability is a security decision

A proxy lets you fix a bug, but it also lets whoever controls the admin key change the rules. We put upgrade rights behind a multisig and, where users need warning, a timelock that delays changes long enough for them to exit.

What an auditor should receive

A frozen commit, the specification, a list of privileged roles, known trade-offs, test coverage and deployment parameters. Teams that send only a repository link pay for days of auditor time spent reconstructing intent.

FAQ

Questions to resolve before the build.

01Do you perform the security audit yourselves?

No. We review our own code rigorously, but an independent audit should come from a firm with no stake in the implementation. We prepare everything they need and fix what they find.

02Can you take over contracts another team started?

Yes. We begin by writing the specification the code should have had, adding tests around existing behaviour, and listing risks before changing anything.

03Is Solidity the only language you use?

It is the one we use most. We also work in Vyper, and in Rust or Move where the target chain needs them, and will tell you if a project falls outside our depth.

04Can a deployed contract be changed?

Only if it was deployed behind a proxy or with explicit upgrade hooks. Otherwise the fix is a new deployment and a migration of users and state, which is why the upgrade decision is made early.

Primary sources

References behind this page

Dated official documentation, standards, and research that support the factual claims on this page.

  1. 01
  2. 02

How to read this page

Scope, cost and timeline figures are planning guidance until confirmed in a written proposal. Diagrams and screens are illustrations, not client deliverables, and source-code rights and handover follow the signed agreement. See the delivery process and the full disclaimer.

Next decision

Turn the brief into an accepted product scope.

Define outcomes, constraints, evidence, rights and handover before delivery begins.

Commercial rights, repositories, environments, documentation, acceptance and handover remain contract-defined.