Which languages and chains do you work with?

We write production smart contracts in Solidity (EVM chains), Rust (Solana, CosmWasm, NEAR), and Vyper where required. We've shipped to Ethereum mainnet, Arbitrum, Base, Polygon, Avalanche, BNB Chain, Solana, and most EVM-compatible L2s.

Do you audit contracts, or only write them?

Every contract we ship passes through internal peer review by a senior engineer not involved in the implementation. For contracts handling significant value, we coordinate third-party audits with firms like Hashlock and prepare the full audit package — documentation, test reports, deployed testnets — so the external audit is productive rather than exploratory.

How long does smart contract development take?

A focused engagement typically runs 4 to 10 weeks end-to-end. Simple token or vesting contracts take 3 to 4 weeks including testing. Complex protocols with custom logic, upgradeability, and multi-contract architectures take 8 to 12 weeks. We scope every project upfront so timelines are committed, not estimated.

Can you upgrade or extend our existing contracts?

Yes. We regularly work with existing codebases — extending upgradeable proxies, adding modules, refactoring for gas efficiency, or migrating to newer patterns. If the contracts are immutable, we design migration paths that preserve state and user balances safely.

What's your track record on deployed contracts?

Zero exploits on audited contracts we've shipped since 2017. Our engineering standard targets 95%+ test coverage, fuzz testing on state-changing functions, and explicit invariant checks. Security isn't a feature we add at the end — it's baked into how we specify, implement, and review every contract.

Blockchain Services

Smart Contract
Development

Smart contracts are the backbone of any blockchain product. They define the rules. Who can do what, under what conditions, with what assets, and what happens when things go wrong.

Engagement

Blockchain Engineering

Typical Duration

4 – 10 weeks

Focus & Stack

SolidityRustVyperFoundryHardhatOpenZeppelinAnchorEVMSolana

We’ve been writing, auditing, and deploying smart contracts since 2017. Tokens, marketplaces, DeFi protocols, governance systems, escrow, vesting, custom business logic. Every contract we ship is secure, gas-efficient, readable, testable, and maintainable.

What we build

Token Contracts

ERC-20, ERC-721, ERC-1155, soulbound tokens, custom standards. Minting, burning, transfer restrictions, allowlists, metadata management, supply controls, vesting schedules.

Access Control & Permissions

On-chain role management, custom RBAC, token-gated access, credential-based permissions. Trustless permission structures that don’t rely on a central authority.

Escrow & Settlement

Time-locked escrow, milestone-based release, multi-party approval, dispute resolution hooks, automatic refund on timeout.

Governance

Voting contracts, proposal systems, delegation, quorum rules, timelock execution. Compatible with Tally, Snapshot, and custom frontends.

Upgradeability

UUPS, Transparent Proxy, and Beacon Proxy patterns. We help teams make the right tradeoff between flexibility and trust.

Custom Business Logic

Loyalty point redemption, insurance claims, supply chain checkpoints, real-world asset tokenisation, subscription management. If the logic is deterministic, it can be a contract.

How we work

Specification — Step 1

Document exactly what the contract system needs to do. Roles, actions, state transitions, invariants, edge cases.

Specification — Step 1

Document exactly what the contract system needs to do. Roles, actions, state transitions, invariants, edge cases.

Architecture — Step 2

How contracts are structured, how they interact, where upgradeability is needed, storage layout, failure handling.

Architecture — Step 2

How contracts are structured, how they interact, where upgradeability is needed, storage layout, failure handling.

Implementation — Step 3

Solidity or Rust, following internal coding standards. OpenZeppelin as foundation where appropriate.

Implementation — Step 3

Solidity or Rust, following internal coding standards. OpenZeppelin as foundation where appropriate.

Testing — Step 4

Unit, integration, edge case, gas profiling, fuzz testing. Targeting 95%+ code coverage.

Testing — Step 4

Unit, integration, edge case, gas profiling, fuzz testing. Targeting 95%+ code coverage.

Internal Review — Step 5

Peer review by a senior engineer not involved in implementation.

Internal Review — Step 5

Peer review by a senior engineer not involved in implementation.

Audit Preparation — Step 6

Clean documentation, deployed testnets, comprehensive test reports.

Audit Preparation — Step 6

Clean documentation, deployed testnets, comprehensive test reports.

Deployment — Step 7

Scripted, repeatable. Testnets first, then mainnet after thorough validation.

Deployment — Step 7

Scripted, repeatable. Testnets first, then mainnet after thorough validation.

Deliverables

What you get

Complete source code with full test suites
Deployment scripts and block explorer verification
NatSpec documentation and architecture diagrams
Audit preparation package
Deployed and verified contracts on target chains
Post-deployment monitoring setup

Token contracts & launches

Tokens look like the simplest contracts a project ships. They are not. The ERC-20, ERC-721, or ERC-1155 standard is the easy part. The hard part is everything attached to it, vesting, allocation buckets, claim mechanics, transfer restrictions, supply controls, and the operational tooling around launch day. Decisions made at the contract level either support the launch or quietly close off options later.

Vesting is where most projects underestimate the work. Linear, cliff-then-linear, and milestone-based schedules each have to be modelled against the cap table, the unlock cliffs, and the governance implications if vesting tokens vote. On Mandala Chain we built the token vesting claim wizard and the staking pools dashboard as part of a wider DeFi suite, integrated directly into the Mandala Hub through shared Wagmi and Polkadot wallet infrastructure. Vesting and staking flows handled significant funds, so the focus was on clean claim UX and contract behaviour that held up under scrutiny. On Earth Fund we shipped a five-component token suite, parent token (1Earth), child DAO tokens, a clearinghouse, a rewards distributor, and a donation router, each composing into the full DAO lifecycle on Ethereum mainnet.

Distribution shapes the early holder base, and bad mechanics are hard to undo. Pectra Staking Manager, built with PierTwo, abstracts EIP-7251 validator consolidation and EIP-7702 batching into a usable interface so institutional stakers do not have to touch raw contract calls at launch. Vana sits on the consumer side of the same problem, the user-owned data hub and integration layer give the protocol a product surface that token holders can actually use. The launch is not an event. It is an operational system, and we treat it that way.

Secure-by-construction

Security is a property of how a contract is specified, written, and reviewed, not a step at the end. Our standard targets 95%+ test coverage with unit, integration, fuzz, and invariant tests on every state-changing function. We use Foundry for property-based testing, Hardhat where the tooling fits better, and OpenZeppelin as the foundation for anything where a battle-tested standard exists. Defensive patterns, checks-effects-interactions, reentrancy guards, pull over push payments, explicit access control on every privileged function, are baseline, not optional.

Internal review is part of the process. Every contract passes through a senior engineer not involved in the implementation before it goes near a testnet. For high-value deployments we coordinate external reviews with firms like Hashlock, and we prepare the review package, clean documentation, full test reports, deployed testnets, so the external pass is productive rather than exploratory. Hashlock is a client of ours on the AI auditor product, not our reviewer, but they are one of several firms we work alongside when a project warrants it.

The proof is in the shipping record. Earth Fund's five-component token suite has been live on Ethereum mainnet across a multi-year partnership. Mandala Chain's DeFi stack, Uniswap V2 fork, Aave V3 fork, staking, vesting, went out across coordinated workstreams without incident. Pectra Staking Manager moved validator-level operations on Ethereum mainnet from launch day. Zero exploits on contracts we have shipped since 2017. That is what secure-by-construction actually looks like, not a marketing claim, just contracts that hold up once real value is on them.

Networks we ship on

Ethereum & EVM

7 projects as proof

Primary ecosystem. Solidity, Foundry, Hardhat, OpenZeppelin patterns. Covers Ethereum mainnet plus EVM-compatible L2s and sidechains including Polygon, Base, Arbitrum and Optimism.

Polygon

2 projects as proof

EVM L2 used where lower fees and tokenisation throughput matter — physical RWA marketplaces and one leg of cross-chain DvP settlement.

Polkadot ecosystem

2 projects as proof

Substrate-based L1/L2 stacks with Wagmi and Polkadot wallet support. Used for full DeFi suites and consumer-facing hub products.

Solana / SVM

2 projects as proof

Solana token-sale infrastructure (Fjord Foundry) and SVM-on-Ethereum-settlement L2 (Eclipse). Smaller portfolio than EVM, named honestly.

Case Study

Blockchain — Cross-Chain — Web3

LayerZero

Atomic, real-time cross-chain settlement for security and payment tokens using LayerZero’s messaging protocol.

Read case study

FAQ

Common questions

Need contracts that handle real value securely?

Smart contract development has been our core discipline since 2017. Zero exploits on audited contracts. If the work is financially consequential, that track record matters.

Start a Technical Consultation