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.

Reviewed by Renat Khasanshyn, Chief Executive Officer at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
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.
Safe or timelock
Deployer key
Contracts and initializers
Tests and CI
Deploy and verify scripts
Audit report
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.
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
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
- 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. - 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. - 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. - 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. - 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?
Who can build Solidity smart contracts for a DeFi protocol, an asset issuer, a fintech app or a chain?
Does Protofire audit the contracts it writes?
Can a deployed smart contract be upgraded?
Can a smart contract development company take over another team's codebase?
What is the difference between smart contract development and DeFi development?
Which languages and chains does Protofire write contracts for?
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.
