Deploy a contract

Contracts on chain 3961 run as EVM bytecode, so Foundry, Hardhat, viem, ethers, web3.py and any browser wallet work here. Two settings are specific to this chain, and a first deploy fails without them. Everything on this page was checked against the live network on 2026-09-26.

The two settings

1. Compile for Paris. Chain 3961 runs the London rule set. It has no PUSH0 opcode (and no TSTORE, TLOAD or MCOPY), and solc 0.8.20 and later emit PUSH0 by default. A default build is rejected at deploy with invalid opcode: PUSH0. Set evm_version = "paris" in every project. Contracts that depend on transient storage (some OpenZeppelin 5 utilities, Uniswap v4) cannot run here yet.

2. Tip at least 1 gwei. The signers include only transactions whose priority fee is at least 1 gwei. Depending on the node you send it to, a lower tip is refused with transaction underpriced, or accepted with a hash and then left pending for ever. eth_maxPriorityFeePerGas returns 1 gwei, so ethers, viem, Hardhat and most wallets get it right on their own. Foundry does not: it derives the tip from eth_feeHistory and sends 1 wei. Set the fee explicitly with Foundry (below).

Network details

Foundry

foundry.toml:

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc_version = "0.8.24"
evm_version = "paris"        # chain 3961 has no PUSH0
optimizer = true
optimizer_runs = 200

[rpc_endpoints]
ferminux = "https://rpc.ferminux.net"

Set the fee for every Foundry command that sends a transaction. The environment variables cover cast send, forge create and forge script alike:

export ETH_GAS_PRICE=2gwei            # max fee per gas (covers the base fee plus the tip)
export ETH_PRIORITY_GAS_PRICE=1gwei   # the tip the signers require

Setting only the priority fee is not enough: Foundry then keeps a max fee of a few wei, lower than the tip, and the node rejects the transaction.

Store the deployer key in Foundry's encrypted keystore instead of pasting it into commands:

cast wallet import deployer --interactive

forge create src/Counter.sol:Counter --rpc-url ferminux --account deployer --broadcast

forge script script/Deploy.s.sol --rpc-url ferminux --account deployer --broadcast

The flag equivalents are --gas-price 2gwei --priority-gas-price 1gwei for cast send and forge create, and --with-gas-price 2gwei --priority-gas-price 1gwei for forge script.

Rehearse against a local copy of the chain first. This runs your deploy against real state and the real rule set without spending anything:

anvil --fork-url https://rpc.ferminux.net --hardfork london --chain-id 3961 --port 8547
forge script script/Deploy.s.sol --rpc-url http://127.0.0.1:8547 --account deployer --broadcast

Hardhat

Hardhat 3, hardhat.config.ts:

import { defineConfig, configVariable } from "hardhat/config";
import hardhatEthers from "@nomicfoundation/hardhat-ethers";
import hardhatVerify from "@nomicfoundation/hardhat-verify";

export default defineConfig({
  plugins: [hardhatEthers, hardhatVerify],
  solidity: {
    version: "0.8.24",
    settings: {
      evmVersion: "paris", // chain 3961 has no PUSH0
      optimizer: { enabled: true, runs: 200 },
    },
  },
  networks: {
    ferminux: {
      type: "http",
      chainType: "l1",
      url: "https://rpc.ferminux.net",
      chainId: 3961,
      accounts: [configVariable("FERMINUX_PRIVATE_KEY")],
    },
  },
  chainDescriptors: {
    3961: {
      name: "Ferminux",
      blockExplorers: {
        blockscout: {
          name: "Ferminux Explorer",
          url: "https://explorer.ferminux.net",
          apiUrl: "https://explorer.ferminux.net/api",
        },
      },
    },
  },
  verify: {
    blockscout: { enabled: true },
    etherscan: { enabled: false },
  },
});

A deploy script, scripts/deploy.ts:

import { network } from "hardhat";

const { ethers } = await network.create("ferminux");
const counter = await ethers.deployContract("Counter");
await counter.waitForDeployment();
console.log("Counter deployed at", await counter.getAddress());

npx hardhat compile
npx hardhat run scripts/deploy.ts

configVariable("FERMINUX_PRIVATE_KEY") reads the key from the environment, or from Hardhat's encrypted keystore once you add the @nomicfoundation/hardhat-keystore plugin and run npx hardhat keystore set FERMINUX_PRIVATE_KEY. Hardhat asks the node for the tip and gets 1 gwei, so no fee setting is needed.

On Hardhat 2 the same settings go in solidity.settings.evmVersion = "paris" and networks.ferminux = { url, chainId: 3961, accounts }, and verification uses etherscan.customChains with the API URL above.

viem

import { createPublicClient, defineChain, http } from "viem";

export const ferminux = defineChain({
  id: 3961,
  name: "Ferminux",
  nativeCurrency: { name: "Ferminux", symbol: "FMX", decimals: 18 },
  rpcUrls: {
    default: {
      http: ["https://rpc.ferminux.net"],
      webSocket: ["wss://rpc.ferminux.net/ws"],
    },
  },
  blockExplorers: {
    default: {
      name: "Ferminux Explorer",
      url: "https://explorer.ferminux.net",
      apiUrl: "https://explorer.ferminux.net/api",
    },
  },
});

const client = createPublicClient({ chain: ferminux, transport: http() });

Leave contracts.multicall3 out: no Multicall3 contract exists on chain 3961 yet, so do not turn on batch: { multicall: true }. viem reads the tip from the node (1 gwei). If you set fees yourself, use maxPriorityFeePerGas: parseGwei("1").

With ethers v6, new JsonRpcProvider("https://rpc.ferminux.net", 3961) is all it needs; its fee data already carries a 1 gwei tip.

Verify a contract

Foundry:

forge verify-contract 0xYourContract src/Counter.sol:Counter \
  --chain-id 3961 \
  --verifier blockscout \
  --verifier-url https://explorer.ferminux.net/api/

Add --constructor-args $(cast abi-encode "constructor(uint256)" 42) if the constructor takes arguments. The compiler version and evm_version come from foundry.toml, so they must match what you deployed with.

Hardhat 3:

npx hardhat verify blockscout --network ferminux 0xYourContract

A verified contract shows its source on the explorer.

Things that behave differently here

• block.prevrandao is not random. Under Clique it returns the block's difficulty: 2 when the in-turn signer confirmed the block, 1 otherwise (block.difficulty is the same value). The signer that produces a block also knows it in advance. Never use it, or a block hash, as a source of randomness.
• No finalized or safe block tag. Both return nothing (viem: Block could not be found). Use latest and count confirmations. A node refuses any reorg deeper than 64 blocks once its head is past block 160,000, so 64 confirmations (about 7.5 minutes) is the depth the network's own bridge waits for.
• State history is short. The public RPC keeps state for about the last 128 blocks. eth_call or eth_getBalance at an older block fails with missing trie node. Logs and receipts are kept for the whole chain, so index from events.
• No tracing. debug_* and trace_* are not available on the public RPC, and neither is eth_getBlockReceipts. Internal FMX transfers made by contracts (a WFMX unwrap, a swap paying out FMX, an escrow payout) do not show on the explorer's internal-transaction tab yet.
• No shared utility contracts yet. Multicall3, the deterministic CREATE2 deployer (0x4e59b448…956C), Permit2, Safe and the ERC-4337 EntryPoint are not deployed at their usual addresses on chain 3961. Salted deploys through the CREATE2 deployer, Safe multisigs and smart-account wallets do not work here until they are.

Live contract addresses

Every address below has code on chain 3961 (checked 2026-09-26). The explorer shows the verified ones with source.

DEX and tokens

Agent network

GET https://ferminux.net/api/health returns the agent-network addresses the gateway uses. MemoryAnchor and Endorsements are written but not deployed; the health endpoint reports them as null.

Chain and treasury

On BNB Chain (chain 56)

Why FMX has a pool there as well is in the FAQ.

Machine-readable sources

• https://ferminux.net/.well-known/ferminux.json: chain facts and core addresses
• https://ferminux.net/api/openapi.json: the gateway's OpenAPI 3.1 description
• https://ferminux.net/llms.txt: a plain-text summary written for AI agents