> For the complete documentation index, see [llms.txt](https://docs.kumbaya.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kumbaya.xyz/developers/building-agents/registry-config.md).

# 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

```ts
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:

```bash
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):

```ts
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

```ts
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.