Skip to content

Ethereum Development Company for Regulated Issuers on Mainnet

Ethereum mainnet orders and finalizes transfers. Your firm decides who may hold the token, who signs and when a transfer is booked. Protofire builds the contracts and ledger service that apply those decisions. The Ethereum Foundation's Ecosystem Support Program funded Protofire's work on Solhint three times.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026

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

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

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

What Ethereum mainnet leaves to an issuer

Ethereum's validators order and finalize transfers, and your firm writes the business rules. Your token contract enforces who may hold the token. Your Safe's signers approve each mint, burn, pause and upgrade. Your ledger's rule sets the block at which a transfer counts as booked. As an Ethereum development company, Protofire builds the contract, the role setup and the booking service for regulated firms that issue or settle on mainnet.

For example, the European Investment Bank and J.P. Morgan have both put tokens on Ethereum mainnet. The European Investment Bank priced a two-year digital bond on 27 April 2021. Its release lists the blockchain as "Ethereum public blockchain". J.P. Morgan's Kinexys brought JPM Coin (JPMD), its USD deposit token, to Ethereum on 19 October 2026.

Protofire builds the parts that mainnet leaves to your firm. We write the token contracts, set each role to your Safe and build the service that sends finalized transfers to your ledger. We also test your contracts on a testnet against the rules of the next upgrade.

Who runs each part of an issuer's setup on Ethereum mainnet

Ethereum's validators finalize blocks, and its client teams ship upgrades. Your firm sets the rules, and Protofire builds the contracts and services that apply them.

The issuer

Holder rules

The issuer decides who may hold the token, and its contract enforces that rule.

Safe and signers

The issuer's Safe holds the mint, burn, pause and upgrade roles.

Ledger and booking rule

The issuer's ledger books each transfer at the block tag the issuer chose.
Ethereum (client teams and validators)

Ordering and finality

Validators propose and attest blocks, and a block finalizes in about 15 minutes.

Protocol upgrades

Client teams decide activation times, and upgrades usually reach testnets first.
Protofire builds

Token contracts

Protofire writes the contracts, and the issuer's keys deploy them.

Ledger service

The service reads receipts at the finalized tag and sends one entry per transfer.

Nodes and upgrade tests

Protofire sets up the client pair and reruns contract and gas tests against the next upgrade's rules.

When an Ethereum transfer counts as final for your ledger

Ethereum finalizes a block in about 15 minutes, and a ledger that books before then can record a transfer that a reorg later removes.Ethereum's JSON-RPC API lets each read name a block tag: "latest", "safe" or "finalized". The "safe" tag returns the latest safe head block, and "finalized" returns the latest finalized block. A transfer read at "latest" has passed neither check.

Finality can also take longer than 15 minutes. Validators that hold a third of the stake can stop it. The protocol starts an inactivity leak when the chain fails to finalize for more than four epochs (ethereum.org). An epoch is 32 slots of 12 seconds.

So your booking rule needs two answers: which tag books an entry, and what your ledger does while finality waits. A ledger that books at "latest" has to reverse entries after a reorg. A fixed 15-minute timer books transfers that are not yet final when finality stalls. The ledger service that Protofire builds records a transfer as pending at "latest". It sends the booking entry once the transfer's block is finalized.

What an Ethereum development company builds for an issuer

Holder rules in the token contract

Your token refuses a transfer to a wallet that your rules exclude. ERC-20 defines transfers and approvals and leaves eligibility to the contract you deploy. Protofire builds an allowlisted ERC-20, an ERC-3643 token with identity checks, or an ERC-7540 vault that takes fund subscriptions and redemptions as requests. Our tokenized deposits page covers a bank's deposit token.

Roles on your Safe, and EIP-7702 delegates reviewed first

Your Safe's signers approve each mint, burn, pause and upgrade. Under EIP-7702, an EOA can also point to delegate code, and the EOA's own key can still send transactions and sign a new delegation. So a delegate does not replace a multisig for treasury roles. An authorization signed with chain ID 0 passes the chain ID check on every chain that supports EIP-7702. Protofire sets each role to your Safe and reviews a delegate before your EOAs point to it.

A ledger feed from finalized blocks

Your ledger receives one entry per transfer, from a block that is finalized. Protofire builds the service that reads receipts at the "finalized" tag, as our blockchain data indexing service does. The service keys each entry by transaction hash and log index, so a retried read updates the same entry.

Batches that fit the gas cap, and ETH on each sending account

Your large distributions go out as several transactions that each fit the cap. Since the Fusaka upgrade, one transaction can use at most 16,777,216 gas (EIP-7825). The splitter that Protofire builds divides a mint to many holders or a coupon run, and your ledger books each part. Each sending account also needs ETH. We add an alert for when its balance falls below your threshold.

Contracts tested against the next upgrade's gas rules

Your team learns on a testnet whether an upgrade breaks a gas assumption in your contracts. As specified in November 2026, the Glamsterdam upgrade raises the gas cost of creating state (EIP-8037) and updates state-access costs (EIP-8038). Both EIPs had Last Call status then. The Ethereum Foundation's testnet announcement says that contracts relying on fixed gas stipends or hardcoded gas limits "may need changes". Protofire reruns your contract tests and gas estimates against those rules on Sepolia.

A poorly implemented delegate can allow a malicious actor to take near complete control over a signer's EOA.
Ethereum Improvement Proposals, EIP-7702, Security Considerations, Standards Track, Core · EIP-7702, read November 2026

Who decides and schedules Ethereum upgrades

No one owns Ethereum, so no single party schedules an upgrade for your firm.On ethereum.org's governance page, a change starts as a Core EIP. Core developers discuss it on AllCoreDevs calls, and the client teams implement it if it is accepted. Upgrades usually activate on testnets before mainnet.

Client teams decide the activation times, according to EIP-7773, the meta EIP for Glamsterdam. The Ethereum Foundation's blog then publishes each activation with its epoch and UTC time.

Glamsterdam shows that a date can move. On 22 October 2026 the Ethereum Foundation announced that core developers had decided on an AllCoreDevs call to postpone the Hoodi activation. The post gives the reason: "to allow for further investigation of interactions of EIP-8037 with mainnet smart contracts". A post on the Foundation's blog, updated on 9 November 2026, says that core developers could revise the specifications of EIP-8037 and EIP-8038. As of November 2026, no new Hoodi date and no mainnet date had been set. So Protofire plans your contract changes against the epoch announced for each network.

Ethereum mainnet facts an issuer's build depends on

Latest upgrade on mainnet
Fusaka, activated on 3 December 2025 at epoch 411,392, the date the Ethereum Foundation had announced.
Fees
A base fee that the protocol sets and burns, plus a priority fee to the validator. Both are paid in ETH.
Account types
EOAs, contract accounts such as a Safe, and EOAs that delegate to contract code under EIP-7702 (Final).
Signature schemes
EOAs sign with secp256k1. Since Fusaka, a precompile lets contract accounts verify secp256r1 (P-256) signatures from secure hardware and passkeys (EIP-7951).
Token standards
ERC-20, ERC-4626, ERC-7540 and ERC-3643 have Final status on eips.ethereum.org.

Read on ethereum.org, eips.ethereum.org and the Ethereum Foundation blog in November 2026.

Our record: Solidity tooling and Safe on Ethereum's testnets

3
Ecosystem Support Program allocations for Solhint
25M+
downloads of Solhint from npm
2023
first Lido grant for our Safe deployment on an Ethereum testnet

Solhint, funded by the Ethereum Foundation

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

Safe on Holesky and Hoodi, funded by Lido's grants organization

Lido's grants organization (LEGO) funded Protofire to deploy Safe on the Holesky testnet in 2023 and on Hoodi in 2025. LEGO has renewed the maintenance grant every half-year through Q4 2026.

From the written proposal to mainnet and later upgrades

  1. Step 1

    Proposal with standard, roles and booking tag

    The written proposal names the token standard, each role and the Safe that holds it, and the tag your ledger books at. It also names where your systems read the chain: your own nodes or an RPC provider.
  2. Step 2

    Contracts and ledger service with tests for batches and stalls

    Protofire writes the contracts and the ledger service in your repository. The tests cover a batch split under the gas cap, a reorg before finality and a finality stall.
  3. Step 3

    Rehearsal on Sepolia with your signers

    The deploy scripts run on Sepolia. Your signers approve mint, burn and pause transactions from a test Safe. The ledger service books test transfers at "finalized".
  4. Step 4

    Mainnet deployment from your keys

    Your engineer runs the reviewed script and signs with your deployer key. Each contract grants its roles to your Safe in the transaction that creates it, and the deployer keeps no role. You own the repository, the contracts and the keys. After launch, Protofire holds no key, signer, owner or admin role.
  5. Step 5

    Upgrade tests after launch

    Under a written scope, Protofire reruns your contract and gas tests when an upgrade reaches a testnet. A change that your contracts need goes to your Safe as a prepared transaction for your signers.

How an Ethereum build with Protofire starts

You send the token terms, the address of the Safe that will hold the roles and your ledger's booking rule.Your team issues the node or RPC credentials that the ledger service uses and keeps them in your vault. The ledger service reads the chain and makes no write call.

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.

Requests outside an Ethereum mainnet build

  • You are still choosing a chain. Our institutional blockchains guide compares Ethereum with Canton and Arc.
  • You want your own rollup that settles to Ethereum and posts blobs. Our rollup development service covers a rollup and its blob fees.
  • You want a relayer, paymaster or bundler run for you, or a validator to delegate to. Protofire does not operate relayers, paymasters or bundlers, and it runs no validators of its own.
  • You need custody of client assets, a license or a legal opinion on the token. Protofire holds no client assets and no license, and your counsel decides the legal questions.

FAQ

What is an Ethereum development company?
An Ethereum development company builds the contracts and services that a firm needs to issue or settle tokens on Ethereum mainnet. Protofire writes the token contracts and sets each role to the firm's Safe. We also build the service that books transfers at finality and test the contracts against the next network upgrade's rules.
Who can build on Ethereum mainnet for a bank or an asset manager?
Protofire builds token contracts, Safe role setups and ledger services on Ethereum mainnet for banks, asset managers and other regulated issuers. The firm keeps three decisions: who may hold the token, who signs and which block its ledger books at.
When is an Ethereum transfer final for our books?
A transfer is final once its block is finalized, which ethereum.org puts at about 15 minutes. Your ledger can read receipts at the "finalized" block tag of the JSON-RPC API. Finality takes longer if validators holding a third of the stake stop attesting. So the booking service keeps a transfer pending until its block is finalized.
Who pays the gas, and does our firm need to hold ETH?
Yes, your firm needs ETH. Each account that sends a transaction pays a base fee, which the protocol burns, and a priority fee to the validator. Your treasury funds each sending account. Blob fees apply only to blob transactions, which rollups send. A firm that issues and settles tokens with ordinary transactions pays no blob fee.
Do we need our own Ethereum nodes, or can we use an RPC provider?
Either works. An Ethereum node runs an execution client and a consensus client. The Ethereum Foundation's Fusaka announcement told node operators to update both for the upgrade. An RPC provider runs that pair for you. Protofire can set up the pair for your engineers or host the nodes through our RPC node hosting service.
What changes for our contracts when Glamsterdam activates on mainnet?
As specified in November 2026, Glamsterdam raises the gas cost of creating state under EIP-8037. For example, a first transfer to a new holder writes a new storage slot, so it would cost more gas under that rule. The upgrade also updates state-access costs under EIP-8038. Core developers were still reviewing both EIPs in November 2026, so the final rules can differ. Glamsterdam has run on Sepolia since 6 October 2026, and it had no mainnet date as of November 2026.

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.