Live registry config

FireRegistry holds protocol-level config that's read by every other launchpad contract at runtime: grace periods, fee splits, force-graduation delays, vesting bounds, etc. Some are constants; others are governance-tunable.

This page shows you how to read each field on-chain so your agent or service can adapt to whatever's currently in force.

Mainnet address

FireRegistry = 0x286B4CB284270C6aE2844875BC92ed7E4C21c4C6   // chain 4326
FireRegistry = 0xaB31c1f84e9c7CcE928a27A8b77fC7De7C310EcA   // chain 6343 (testnet)

Constants (immutable)

These are hardcoded in the contract and never change without a redeploy. Worth caching client-side after a single read:

Field	Value	Meaning
MIN_POSITIONS	5	Minimum bonding-curve positions per launch
MAX_POSITIONS	50	Maximum bonding-curve positions per launch
MIN_VESTING_DURATION	90 days	Lower bound for vestingDuration
MAX_VESTING_DURATION	730 days	Upper bound
MAX_SKIM_BPS	1500	Max 15% skim per buy
MAX_CREATOR_ALLOCATION_BPS	2000	Max 20% on-token creator allocation
MIN_BURN_COUNTDOWN	1 days	Lower bound for FuelVault burn timer
MAX_BURN_COUNTDOWN	90 days	Upper bound
MIN_GRACE_PERIOD	1 hours	Lower bound for gracePeriodDuration
MAX_GRACE_PERIOD	7 days	Upper bound
MIN_FORCE_GRADUATION_DELAY	90 days	Lower bound for forceGraduationDelay

Tunable values (governance-set)

These can change between launches. Always read live before depending on them.

Field	Type	Used for
gracePeriodDuration()	uint256	Wait between recordGraduationCondition and permissionless graduate
forceGraduationDelay()	uint256	Time after createdAt after which anyone can force-graduate
burnCountdownDuration()	uint256	Wait between graduation and executeBurn eligibility
fuelVestedBps()	uint16	Pre-grad gift split - fraction that goes to vested bucket
requiredFeeTier()	uint24	Forced fee tier for new launches (e.g. 10000)
requiredSkimBps()	uint16	Forced skim bps for new launches
treasury()	address	Protocol fee recipient (pre-grad graduationFeeBps share). Same address as integrator() today.
integrator()	address	Protocol fee recipient (pre-grad remainder). Same address as treasury() today, so all pre-grad fees go to the protocol.
guardian()	address	Address that can graduate immediately and relay gifts
owner()	address	Registry admin
minGiftAmount()	uint256	Floor on giftWithSig amounts
streamingRecipientsLocked()	bool	Whether the streaming-recipient list is permanently locked
getStreamingRecipientsTotalBps()	uint16	Sum of bps across protocol recipients (creator gets 10000 - this)
getStreamingRecipients()	StreamingRecipient[]	Full list (max 10 entries) of (address, bps)
getStreamingRecipientsCount()	uint256	List size

Reading with viem

import { createPublicClient, http } from 'viem'
import { fireRegistryAbi } from './abis/fireRegistry' // from fire/out after `forge build`

const REGISTRY = '0x286B4CB284270C6aE2844875BC92ed7E4C21c4C6'
const client = createPublicClient({ transport: http('https://mainnet.megaeth.com/rpc') })

const [
  gracePeriod,
  forceDelay,
  burnCountdown,
  treasury,
  integrator,
  guardian,
  totalRecipientBps,
  recipients,
] = await client.multicall({
  contracts: [
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'gracePeriodDuration' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'forceGraduationDelay' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'burnCountdownDuration' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'treasury' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'integrator' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'guardian' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'getStreamingRecipientsTotalBps' },
    { address: REGISTRY, abi: fireRegistryAbi, functionName: 'getStreamingRecipients' },
  ],
  allowFailure: false,
})

const creatorBps = 10_000 - Number(totalRecipientBps)
console.log(`Grace period: ${gracePeriod}s`)
console.log(`Force graduation: ${forceDelay}s after createdAt`)
console.log(`Burn countdown: ${burnCountdown}s after graduation`)
console.log(`Creator share: ${creatorBps} bps (${creatorBps / 100}%)`)
console.log(`Recipients:`, recipients)

Reading with cast

If you've got Foundry installed, one-liner reads work too:

RPC=https://mainnet.megaeth.com/rpc
REG=0x286B4CB284270C6aE2844875BC92ed7E4C21c4C6

cast call $REG "gracePeriodDuration()(uint256)"          --rpc-url $RPC
cast call $REG "forceGraduationDelay()(uint256)"         --rpc-url $RPC
cast call $REG "burnCountdownDuration()(uint256)"        --rpc-url $RPC
cast call $REG "fuelVestedBps()(uint16)"                 --rpc-url $RPC
cast call $REG "treasury()(address)"                     --rpc-url $RPC
cast call $REG "integrator()(address)"                   --rpc-url $RPC
cast call $REG "guardian()(address)"                     --rpc-url $RPC
cast call $REG "getStreamingRecipientsTotalBps()(uint16)" --rpc-url $RPC

For getStreamingRecipients() you get a struct array - easier to handle in viem than cast.

Reading per-launch state

For values snapshotted at ignite() time (per-token):

import { fireGraduatorAbi } from './abis/fireGraduator'

const GRADUATOR = '0xCCA4759167Ef4214dF98Eb7cBbCE47EB9B4F2585'

const launchState = await client.readContract({
  address: GRADUATOR,
  abi:     fireGraduatorAbi,
  functionName: 'launchState',
  args:    [tokenAddress],
})

// launchState includes: creator, createdAt, graduationConditionMetAt,
// graduated, graduationFeeBps, isToken0, graduationTick, etc.

graduationFeeBps here is the pre-graduation protocol share for that specific token, snapshotted at launch.

Reading the recipient lock state

const locked = await client.readContract({
  address: REGISTRY,
  abi:     fireRegistryAbi,
  functionName: 'streamingRecipientsLocked',
})

if (locked) {
  // The creator's post-grad share is now permanently fixed.
  // (10_000 - getStreamingRecipientsTotalBps()) / 10_000 is forever.
}

This is a useful integrator/creator confidence check - once locked, the protocol cannot reduce the creator's cut later.

What changes when

• Constants - never, without a redeploy.

• Tunables - by owner() only, via setter functions on the registry. Each setter emits an event (GracePeriodDurationUpdated, ForceGraduationDelayUpdated, etc.) - subscribe to those if you need to react in real time.

• Streaming recipients - by owner() until lockStreamingRecipients() is called, after which they're permanently fixed.