Quick answer: The error “only replay-protected (EIP-155) transactions allowed over RPC” means you signed a legacy transaction without a chain ID, and the node you sent it to refuses to broadcast it. The fix is to add the network’s chain ID before signing (1116 for Core mainnet, 1114 for Core Testnet2), or to send a typed EIP-1559 transaction, which always carries a chain ID. Only node operators can switch the check off, using the --rpc.allow-unprotected-txs flag.
You’ll almost always hit this in your own code: a web3.py, ethers.js or web3j script, a hand-built raw transaction, or an old “keyless” deployment transaction. Below you’ll find what the message means, why Core users only see it with some RPC endpoints, and the exact fix for each common tool.
What “replay-protected” actually means
Before EIP-155, a signed transaction didn’t say which chain it was for. The same signed bytes could be valid on any EVM chain where the sender had the same address and a matching nonce, so someone could “replay” your transaction on a different network.
EIP-155 fixed this by adding the chain ID to the data that gets signed. You can see which kind of signature you have from the v value:
- Unprotected (pre-EIP-155):
vis 27 or 28. - Protected (EIP-155):
v = chainId × 2 + 35or+ 36. For Core mainnet (chain ID 1116), that works out to 2267 or 2268.
Typed transactions, such as EIP-2930 and EIP-1559 (type 2) transactions, keep the chain ID in a separate field. In go-ethereum’s code, the Protected() check only ever fails for a legacy transaction whose v isn’t EIP-155 style. Every other type counts as protected automatically.

Why the node rejects it
The rule comes from go-ethereum (Geth). The Geth v1.10.0 release notes (March 2021) explain that Geth started rejecting transactions that aren’t replay-protected when they’re submitted over RPC. It didn’t make them invalid at the consensus level. Operators who still needed the old behaviour got the --rpc.allow-unprotected-txs flag, which the Geth team called a temporary mechanism. The error string is still in current Geth’s RPC code.
Core’s node software, core-chain, is a Geth-based client (v1.0.27 was released on 31 October 2026). Its source has the same check, the same error message and the same --rpc.allow-unprotected-txs flag. So a Core node running with default settings rejects unprotected transactions sent over RPC, exactly like Ethereum’s Geth does.
Why you see it on some Core RPCs but not others
Whether you get the error depends on how the node behind your RPC URL is configured. On 15 November 2026 we signed a zero-value legacy transaction without a chain ID from a newly generated, empty test wallet, then submitted it to several public Core mainnet endpoints. An empty wallet means nothing could actually be sent. These were the responses:
| Core mainnet RPC | Response to an unprotected transaction | What it tells you |
|---|---|---|
https://rpc.coredao.org (official) | “insufficient funds for gas * price + value” | Passed the replay check and failed later only because the test wallet was empty |
https://core.drpc.org | “insufficient funds for gas * price + value” | Same as above |
https://rpc.ankr.com/core | “only replay-protected (EIP-155) transactions allowed over RPC” | The node enforces Geth’s default rule |
The same EIP-155-signed transaction (chain ID 1116, v = 2268) got past the replay check everywhere and only failed on the empty balance. Two lessons:
- If your script “works on one RPC and fails on another,” the missing chain ID is the bug. The RPC that accepts it is just more permissive.
- Don’t rely on a permissive endpoint. Providers can change their settings at any time, so always sign with a chain ID.
Core’s official endpoints and chain IDs are listed on its network configuration page. If you’re setting up a wallet, our guide to adding Core to MetaMask has the same details.
How to fix it
web3.py / eth-account
eth-account will sign a legacy transaction with no chainId, and the result is unprotected (v = 27 or 28). Add the chain ID before you sign:
tx = {
"nonce": w3.eth.get_transaction_count(acct.address),
"to": recipient,
"value": w3.to_wei(0.01, "ether"),
"gas": 21000,
"gasPrice": w3.eth.gas_price,
"chainId": w3.eth.chain_id, # 1116 on Core mainnet
}
signed = acct.sign_transaction(tx)
w3.eth.send_raw_transaction(signed.raw_transaction)
Reading w3.eth.chain_id from the provider is safer than hard-coding a number. That’s the pattern Chainstack’s write-up of this error uses too.
ethers.js (v6)
When you send through a Wallet connected to a provider, ethers fills in the network’s chain ID for you (see abstract-signer.ts). The error usually appears when you build and sign a legacy transaction offline with wallet.signTransaction() and leave out chainId. In ethers’ legacy serializer, a chain ID of 0 means no EIP-155. Either pass chainId: 1116 or let a connected wallet populate the transaction before signing.
viem
viem takes the chain ID from the chain object on your wallet client. Create the client with viem’s built-in coreDao chain (id 1116) or coreTestnet2 from viem/chains, rather than signing without any chain context.
web3j and other low-level signers
Older web3j code that signs without a chain ID produces unprotected transactions. The fix reported in web3j issue #1397 is to pass the chain ID explicitly, for example TransactionEncoder.signMessage(rawTx, chainId, credentials) or a RawTransactionManager created with the chain ID.
Switch to EIP-1559 transactions
A type-2 transaction always includes the chain ID, so it can’t trigger this error. If your library supports it, set maxFeePerGas and maxPriorityFeePerGas instead of gasPrice. If you then hit a fee error, see our guide to “max fee per gas less than block base fee”.
If you run your own node
Only start a Geth or core-chain node with --rpc.allow-unprotected-txs if you truly need to relay pre-signed legacy transactions. Never expose that node’s RPC to the public. Fixing the signer is the better solution.
The one legitimate case: keyless deployment transactions
Some tools deploy a contract to “the same address on every chain” with a pre-signed transaction from a one-time account. The best-known example is Arachnid’s deterministic deployment proxy (the CREATE2 factory at 0x4e59b44847b379578588920ca78fbf26c0b4956c). It only works because it has no chain ID: its published deployment transaction has v = 27. Default nodes reject transactions like this over RPC.
On Core, you probably don’t need to broadcast it at all. An eth_getCode call to that address on rpc.coredao.org on 15 November 2026 returned the proxy’s bytecode, so the factory is already deployed on Core mainnet. Check with eth_getCode before you try to deploy it yourself.
A related error: “invalid chain id for signer”
Including a chain ID isn’t enough on its own. It has to be the right one. When we sent the same test transaction signed for chain ID 1 to Core’s RPC, it was rejected with invalid sender: invalid chain id for signer: have 1 want 1116. If you see this, your script is pointing at Core but signing for another network, which often happens when a config file is copied from an Ethereum project. Once the transaction goes through, normal errors like “nonce too low” or “replacement transaction underpriced” are handled as usual.
FAQ
Is my wallet or my money at risk because of this error?
No. The node refused to broadcast the transaction, so nothing was sent and no gas was spent. The message just means the signature didn’t include a chain ID.
Why does the same script work on rpc.coredao.org but fail on another Core RPC?
RPC operators choose whether to enforce Geth’s default check. In our 15 November 2026 test, Core’s official RPC accepted unprotected transactions and Ankr’s Core endpoint rejected them. Sign with chain ID 1116 and your script will work on both.
What chain ID should I use for Core?
1116 (0x45c) for Core mainnet and 1114 (0x45a) for Core Testnet2, according to Core’s docs. You can confirm it with an eth_chainId call to your RPC.
Is turning on –rpc.allow-unprotected-txs dangerous?
It lets your node relay transactions that could be replayed on other EVM chains where the same key holds funds. Geth describes the flag as a temporary compatibility option. Use it only on a private node, and only when you have to.
Disclaimer: This article is for educational purposes only and isn’t financial or investment advice. Always test scripts with small amounts or on a testnet first, and never share your private keys.
