Skip to content

Smart Contract Development Company for EVM Teams That Hold Their Upgrade Keys

Protofire is a smart contract development company that writes, tests and verifies Solidity contracts for EVM networks. Your Safe or timelock holds each upgrade key from the first transaction. We maintain Solhint, the Solidity linter downloaded 25M+ times from npm, and the Ethereum Foundation funded Solhint three times.

Renat Khasanshyn

Reviewed by Renat Khasanshyn, Chief Executive Officer at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. Why it matters
  3. What you get
  4. Upgrade keys
  5. Why Protofire
  6. How it runs
  7. How work starts
  8. Not the right fit
  9. Related guides and services
  10. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

Who controls your contracts after launch

A few deployment transactions decide who can change your contracts the day after launch. Each proxy has an admin, each token has a minter and each vault has a pauser. Each of those roles is an address that someone holds a key for. For example, your contracts can be written and your audit booked while the question of who can change them is still open.

Protofire is a smart contract development company that writes the Solidity and sets each admin, minter and pauser role to your Safe or timelock. Each role is set in the transaction that creates its contract, and an explorer shows who holds which role.

Who writes, reviews and controls a Solidity contract system

Protofire writes and tests the contracts. An audit firm you pick reviews the tagged commit, and your Safe holds the roles from the first transaction.

Client

Safe or timelock

Your Safe or timelock holds the ProxyAdmin owner, UUPS upgrader, beacon owner, pauser and minter roles, which are set as each contract is created.

Deployer key

The deployer key sends the deployment transactions and keeps no role once they confirm.
Protofire builds

Contracts and initializers

Protofire writes the Solidity source, its storage namespaces and the initializer that each proxy runs once.

Tests and CI

Unit, fuzz and invariant tests run in CI, and Solhint and Slither check each pull request.

Deploy and verify scripts

The scripts pin the compiler settings, run once per network and verify the source on each explorer.
Audit firm the client picks

Audit report

The audit report reviews the tagged commit, and its reviewers did not write the code.

The deployment script decides who holds the upgrade key

The deployment script decides which address gets the power to upgrade a proxy.In OpenZeppelin Contracts 5.x, a transparent proxy deploys its own ProxyAdmin, which is owned by the initialOwner passed at construction. A UUPS contract checks a role inside its implementation instead. If the script names the deployer's address in either place, the deployer key keeps the right to replace your contract. That key was only meant to send transactions.

The compiler is the second place where a contract fails late. Solidity 0.8.38, released on 22 October 2026, fixed an optimizer bug that affected versions 0.8.19 through 0.8.37. Once a contract holds funds, fixing a wrong upgrade key or a compiler bug takes a signed transaction, a redeploy or both.

An audit reads the code at one tagged commit, but the key holder is whoever the deployment named.

[...] even if your smart contract code is bug-free, the compiler or the platform itself might have a bug.
Solidity team, Security Considerations, Solidity documentation, Maintainers of the Solidity compiler · Solidity documentation for 0.8.38, read November 2026

What Protofire delivers as a smart contract development company

Your signers hold the upgrade keys

Your Safe or timelock holds the right to replace your contracts. Protofire's deploy scripts set the proxy admin owner, the UUPS upgrader and the beacon owner to your Safe or timelock. Each of those roles is set in the transaction that creates the contract, so the deployer address ends with no role.

Roles and proxy choices written down first

Your reviewers can follow the contracts because each privileged function, the key behind it and the reason for the proxy pattern are written down first. Protofire writes Solidity on OpenZeppelin Contracts 5.x where a library contract fits. We give upgradeable contracts ERC-7201 storage namespaces.

Tests and checks on each pull request

A broken invariant stops the merge. Protofire runs unit, fuzz and invariant tests in Foundry or Hardhat 3. Solhint and Slither run on each pull request, and Echidna campaigns run on the invariants that guard funds. No tool proves the code free of bugs.

Upgrades simulated before your signers approve

Your signers see what an upgrade does before they sign. Protofire diffs the new storage layout against the deployed one and rehearses the upgrade call on a fork. We also prepare the transaction for your Safe.

Verified source that matches the bytecode on three explorers

People who read your contract on Etherscan, Sourcify and Blockscout see the source you reviewed. Protofire verifies the source from the commit and compiler settings that produced the bytecode.

Code prepared for the audit firm you pick

The audit firm you hire gets a tagged commit, a scope file and the role design. Then the firm gets one pull request per finding to re-check. The deployed bytecode matches the commit that the firm reviewed.

Who holds the upgrade key in each proxy pattern

Protofire's deployment scripts set each key below to your Safe or timelock when the proxy is created.

Transparent proxy

Who holds the upgrade key: The owner of the ProxyAdmin that the proxy deploys, set as initialOwner at construction (OpenZeppelin)

What one upgrade call changes: One proxy's implementation

How you check it: The ERC-1967 admin slot names the ProxyAdmin, and the explorer shows its owner

UUPS proxy

Who holds the upgrade key: The role that _authorizeUpgrade checks in the implementation. OpenZeppelin says this upgrade logic "can eventually be removed"

What one upgrade call changes: One proxy's implementation, which can also drop the upgrade function

How you check it: Role holders on the proxy, and Upgraded events

Beacon proxy

Who holds the upgrade key: The owner of the UpgradeableBeacon. A proxy's beacon "can only be set once during construction"

What one upgrade call changes: Every proxy that follows the beacon, at once

How you check it: The ERC-1967 beacon slot, then the beacon's owner

Diamond (ERC-2535)

Who holds the upgrade key: Whoever the diamond's own check allows to call diamondCut. ERC-2535 says ownership "is not part of this standard"

What one upgrade call changes: Functions, through facets that reach the diamond's storage

How you check it: Loupe functions list facets, and DiamondCut events log changes

EIP-7702 account

Who holds the upgrade key: The account's own private key, which signs each new delegation (EIP-7702)

What one upgrade call changes: The code the account runs. The account keeps its storage

How you check it: The account's code reads 0xef0100 followed by the delegate's address

No proxy

Who holds the upgrade key: No key. A fix means a new address and a migration

What one upgrade call changes: Nothing

How you check it: Bytecode and source on the explorer

Our Solidity record: Solhint, Certora and Kyber

25M+
downloads of Solhint from npm
3
Ethereum Foundation allocations that funded Solhint
2017
the year Solhint first shipped on npm

Other organizations name Protofire for Solidity tooling and contracts.Two engagements below are past, and the Solhint work is ongoing.

Solhint, the Solidity linter we maintain

Protofire created Solhint in 2017 and maintains it. Developers have downloaded Solhint from npm 25M+ times, and the Solidity documentation lists it among its resources. The Ethereum Foundation's Ecosystem Support Program funded the work in Q4 2022, Q4 2023 and Q1 2025. The Q1 2025 allocation was for ongoing maintenance and support. Our Solhint page describes the linter.

Certora's 2024 audit of our ve8020 Launchpad contracts

In 2023 Balancer's grants program funded Protofire to build the open-source ve8020 Launchpad, a vote-escrow staking framework for Balancer pools. Certora audited the Launchpad's Solidity contracts and published its report in March 2024.

KyberDAO's pool master proxy, written in 2020

In 2020 Protofire wrote KyberDAO's pool master proxy. Kyber Network announced it on 28 May 2020 as a smart contract proxy for non-custodial KNC staking and voting delegation.

How a Solidity contract build with Protofire runs

  1. Step 1

    Written proposal with proxy patterns and role holders

    The written proposal names the proxy pattern for each contract, who holds each role and the compiler settings for each network.
  2. Step 2

    Build with pinned compiler settings

    The compiler version, the optimizer runs and an EVM target that the chain's fork supports are recorded in the config and the metadata. A compiler release that lists an important bugfix triggers a check of the code that the release names.
  3. Step 3

    Rehearsal on a fork, then a testnet

    The deploy scripts run against a fork of the target network, then on its testnet. Each run prints the admin of each proxy and the holder of each role. Protofire diffs an upgrade's storage layout against the deployed layout first.
  4. Step 4

    Your engineer deploys

    Your engineer runs the reviewed script in your own environment and signs with the deployer key from your wallet or signing service. Protofire's machines and CI do not hold that key. A transparent proxy receives your Safe or timelock as initialOwner. A UUPS contract grants its upgrader role in the initializer of the same transaction. The deployer address ends with no role.
  5. Step 5

    Verification and handover

    Protofire verifies the source on Etherscan, Sourcify and the chain's Blockscout. A changed comment or a renamed variable breaks a Sourcify exact match. So verification runs from the commit and settings that produced the deployed bytecode. You own the repository, the addresses and the keys. After launch, Protofire holds no owner, admin, upgrader, pauser or signer role.

How work with Protofire starts

Work with Protofire starts when you send the specification or repository and the EVM networks you will deploy on.You also send the address of the Safe or timelock that will hold the keys. For a system that is already deployed, you add its deploy scripts and logs under NDA, with secrets removed. Our commercial terms are on how we work.

Proposal
In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
Price
Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
Ownership
Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
After launch
Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
Access
Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
Licenses
Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.

How we work shows a worked proposal.

When a custom Solidity build does not fit

  • You need a token with no custom rules. OpenZeppelin's ERC-20, deployed as it is, will do. Our token launch service covers the token's distribution and economics.
  • You need deployed contracts watched and responses prepared under your keys. That is our managed onchain operations service, which runs under a written scope.
  • You need programs for non-EVM runtimes. Protofire's contract work is Solidity for EVM networks.

FAQ

What is smart contract development?
Smart contract development is the design, writing, testing and deployment of the onchain code a product runs on. Protofire develops smart contracts in Solidity for EVM networks. Our work covers role and upgrade design, test suites and verification on explorers. Deployment runs from the client's own keys, so the client's Safe or timelock holds each upgrade key from the first transaction.
Who can build Solidity smart contracts for a DeFi protocol, an asset issuer, a fintech app or a chain?
Protofire writes Solidity for EVM networks for these four kinds of buyer, and the buyer decides who holds each key. A DeFi team gets core contracts for a DEX, lending market, vault or staking system. Our DeFi development page covers choosing the product first. An issuer gets an ERC-20 with mint, burn, pause and blocklist roles, or a permissioned token through ERC-3643 development. A fintech gets ERC-4626 vaults, escrow and payment contracts, or delegate code for EIP-7702 accounts. Our oracle integration service covers the prices those contracts read. A chain team gets its own contracts at known addresses and shared contracts such as deterministic factories. Our L1 and L2 chain work covers the chain around those contracts.
Does Protofire audit the contracts it writes?
An audit firm that took no part in the build reviews the contracts Protofire writes. Protofire's job is to get the code ready for that review and to fix what the review finds. An audit lowers risk, but it does not promise code free of bugs. For contracts that another team built, Protofire offers a smart contract audit service.
Can a deployed smart contract be upgraded?
Yes, if the contract was deployed behind a proxy or as a diamond, and only by whoever holds that pattern's upgrade key. A contract without a proxy or a diamond cannot change, so a fix means a new address and a migration. A UUPS implementation can later drop its upgrade function, which fixes the logic for good.
Can a smart contract development company take over another team's codebase?
Yes. Protofire builds the repository at each tagged commit and compares the output with the deployed bytecode. We then read each proxy's ERC-1967 slots and the role holders from the chain. New code waits until the bytecode comparison and the role holders are known. A gap shows up in one of three places. First, no commit reproduces the deployed bytecode. Second, a departed developer's address holds a key. Third, an upgrade was planned on a storage layout that nobody wrote down. Each gap and its fix go into the first written proposal. An exploit in progress is work for our protocol rescue service.
What is the difference between smart contract development and DeFi development?
Smart contract development delivers the contracts, their keys and their release path for the product you design. DeFi development covers choosing a financial product type and the code to start from. It then covers the contracts, price adapters, indexer and app built on that code. A team with a product still to design starts with DeFi development.
Which languages and chains does Protofire write contracts for?
Protofire writes contracts in Solidity, for Ethereum and other EVM networks. The compiler's EVM target is set for each network, because a chain that has not adopted Ethereum's latest fork may lack that fork's opcodes. Programs for non-EVM runtimes are outside this service.

Get a proposal

Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.

Luis MedeirosField CTO, reads every request · LinkedIn

A demo or repository link also works.