Smart Contracts

The core ERC-20 token of the Inferno protocol. Inherits from OpenZeppelin's ERC20, ERC20Burnable, and Ownable. Uses 9 decimals (not the standard 18) and a total supply of 1 billion IFR. Implements a fee-on-transfer mechanism: every non-exempt transfer deducts a sender burn fee, a recipient burn fee, and a pool fee. The combined fee rate is capped at 5%. Default rates are 2.0% sender burn, 0.5% recipient burn, and 1.0% pool fee (3.5% total).

Constructor

State Variables

Functions

Internal Functions

Events

ethers.js Example

const { ethers } = require("ethers");

const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";
const abi = [
  "function decimals() view returns (uint8)",
  "function balanceOf(address) view returns (uint256)",
  "function senderBurnBps() view returns (uint256)",
  "function recipientBurnBps() view returns (uint256)",
  "function poolFeeBps() view returns (uint256)",
  "function feeExempt(address) view returns (bool)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function setFeeExempt(address account, bool exempt)",
];

const provider = new ethers.JsonRpcProvider(RPC_URL);
const token = new ethers.Contract(TOKEN_ADDR, abi, provider);

// Read fee rates
const senderBurn = await token.senderBurnBps();   // 200 = 2.0%
const recipBurn  = await token.recipientBurnBps(); // 50  = 0.5%
const poolFee   = await token.poolFeeBps();       // 100 = 1.0%

// Calculate net transfer amount (for 1000 IFR)
const amount = ethers.parseUnits("1000", 9);
const totalFee = (amount * (senderBurn + recipBurn + poolFee)) / 10000n;
const netAmount = amount - totalFee;
console.log("Net received:", ethers.formatUnits(netAmount, 9), "IFR");

// Transfer tokens (signer required)
const signer = await provider.getSigner();
const tokenWithSigner = token.connect(signer);
await tokenWithSigner.transfer(recipientAddr, amount);

Holds 200M IFR as a strategic liquidity reserve with a time-lock and staged withdrawal mechanism. Tokens are locked for an initial lock period (6 months in production). After the lock expires, withdrawals are rate-limited to a maximum amount per period (currently 50M IFR per 90 days) to prevent supply shocks. The per-period maximum is owner-settable via setMaxWithdrawPerPeriod (owner: Governance, 48h timelock); only the period length is immutable. Includes a guardian role for emergency pause/unpause.

Constructor

Functions

Events

ethers.js Example

const RESERVE_ADDR = "0xF7E90D0d17f8232365186AA085D26eaEfAf011aF";
const abi = [
  "function lockEnd() view returns (uint256)",
  "function currentPeriod() view returns (uint256)",
  "function availableToWithdraw() view returns (uint256)",
  "function pendingBalance() view returns (uint256)",
  "function withdraw(address to, uint256 amount)",
  "function paused() view returns (bool)",
];

const reserve = new ethers.Contract(RESERVE_ADDR, abi, provider);

// Check lock status
const lockEnd = await reserve.lockEnd();
const now = Math.floor(Date.now() / 1000);
console.log("Locked:", now < Number(lockEnd));

// Check available withdrawal
const available = await reserve.availableToWithdraw();
console.log("Available:", ethers.formatUnits(available, 9), "IFR");

// Withdraw (owner only, via governance proposal)
const amount = ethers.parseUnits("10000000", 9); // 10M IFR
await reserve.connect(owner).withdraw(treasuryAddr, amount);

Linear vesting contract for 150M IFR team allocation. Implements a 12-month cliff followed by 36-month linear vesting. No tokens are releasable before the cliff. After the cliff, tokens vest linearly based on elapsed time. The beneficiary calls release() to claim vested tokens. A guardian can pause releases for emergency situations.

Constructor

Functions

Events

Custom Errors

ethers.js Example

const VESTING_ADDR = "0xa710f9FE7bf42981E60BE2Fbe7D87Fb3541a3F8B";
const abi = [
  "function beneficiary() view returns (address)",
  "function vestedAmount() view returns (uint256)",
  "function releasableAmount() view returns (uint256)",
  "function released() view returns (uint256)",
  "function vestingSchedule() view returns (uint256, uint256, uint256)",
  "function release()",
];

const vesting = new ethers.Contract(VESTING_ADDR, abi, provider);

// Check vesting progress
const [start, cliff, duration] = await vesting.vestingSchedule();
const vested = await vesting.vestedAmount();
const releasable = await vesting.releasableAmount();
const released = await vesting.released();

console.log("Vested:", ethers.formatUnits(vested, 9), "IFR");
console.log("Releasable:", ethers.formatUnits(releasable, 9), "IFR");
console.log("Released:", ethers.formatUnits(released, 9), "IFR");

// Release vested tokens (beneficiary only)
await vesting.connect(beneficiarySigner).release();

Accepts ETH deposits and uses them to buy IFR tokens on Uniswap V2. Purchased tokens are split 50/50 between the BurnReserve (permanent burn) and the treasury. Features a configurable activation delay (60 days in production), a cooldown between buybacks (default 1 hour), and slippage protection (default 5%) using price quotes recorded at deposit time.

Constructor

State Variables

Functions

Events

ethers.js Example

const VAULT_ADDR = "0xC8ABb9039BEd24f4dBf5Cff09699877D81f0D63C";
const abi = [
  "function depositETH() payable",
  "function executeBuyback()",
  "function activationTime() view returns (uint256)",
  "function lastBuybackAt() view returns (uint256)",
  "function cooldown() view returns (uint256)",
  "function pendingExpectedOut() view returns (uint256)",
  "function paused() view returns (bool)",
];

const vault = new ethers.Contract(VAULT_ADDR, abi, provider);

// Deposit ETH for future buyback
await vault.connect(signer).depositETH({
  value: ethers.parseEther("0.5"),
});

// Check if buyback is ready
const activation = await vault.activationTime();
const lastBuyback = await vault.lastBuybackAt();
const cd = await vault.cooldown();
const now = Math.floor(Date.now() / 1000);

const isActive = now >= Number(activation);
const cooldownPassed = now >= Number(lastBuyback + cd);
console.log("Ready:", isActive && cooldownPassed);

// Execute buyback (owner only)
await vault.connect(owner).executeBuyback();

Permanent token burning contract with on-chain tracking. Tokens are deposited via deposit() (requires prior approval) or sent directly from BuybackVault. The owner or guardian can then call burn() or burnAll() to permanently destroy the tokens, reducing the total supply. Tracks cumulative totalBurned for transparency.

Constructor

Functions

Events

ethers.js Example

const BURN_ADDR = "0x6D4582FCac792FD3880e252fC0a585A0c1823e80";
const abi = [
  "function pendingBurn() view returns (uint256)",
  "function totalBurned() view returns (uint256)",
  "function deposit(uint256 amount)",
  "function burn(uint256 amount)",
  "function burnAll()",
];

const burnReserve = new ethers.Contract(BURN_ADDR, abi, provider);

// Check burn stats
const pending = await burnReserve.pendingBurn();
const totalBurned = await burnReserve.totalBurned();
console.log("Pending burn:", ethers.formatUnits(pending, 9));
console.log("Total burned:", ethers.formatUnits(totalBurned, 9));

// Deposit tokens (requires prior token.approve())
const amount = ethers.parseUnits("100000", 9);
await token.connect(signer).approve(BURN_ADDR, amount);
await burnReserve.connect(signer).deposit(amount);

// Burn all pending tokens (owner or guardian)
await burnReserve.connect(owner).burnAll();

Timelock-based governor for the Inferno protocol with a 48-hour delay. All protocol contracts have their ownership transferred to this contract, ensuring that parameter changes (fee rates, treasury address, etc.) go through the timelock. The owner proposes parameter changes; after the delay passes, the owner can execute them. The guardian (or owner) can cancel pending proposals for emergency response. The delay itself can only be changed via a governance proposal (self-call).

Constructor

Proposal Struct

Functions

Events

ethers.js Example

const GOV_ADDR = "0x6050b22E4EAF3f414d1155fBaF30B868e0107017";
const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";

const govAbi = [
  "function propose(address target, bytes data) returns (uint256)",
  "function execute(uint256 proposalId)",
  "function cancel(uint256 proposalId)",
  "function getProposal(uint256) view returns (address, bytes, uint256, bool, bool)",
  "function delay() view returns (uint256)",
  "function proposalCount() view returns (uint256)",
];

const gov = new ethers.Contract(GOV_ADDR, govAbi, provider);

// Create a proposal to update fee rates on InfernoToken
const iface = new ethers.Interface([
  "function setFeeRates(uint256, uint256, uint256)",
]);
const calldata = iface.encodeFunctionData("setFeeRates", [150, 50, 100]);

const tx = await gov.connect(owner).propose(TOKEN_ADDR, calldata);
const receipt = await tx.wait();
const proposalId = receipt.logs[0].args.id;

// After delay has passed, execute
await gov.connect(owner).execute(proposalId);

// Read a proposal
const [target, data, eta, executed, cancelled] =
  await gov.getProposal(proposalId);

Generic token lock contract designed for multi-application use. Users lock IFR tokens (with an optional lockType tag) and external resolvers query isLocked() to gate access to features (e.g. premium content, voting weight, staking tiers). Inherits OpenZeppelin's ReentrancyGuard and Pausable. No rewards or vesting -- purely a lock/unlock mechanism with on-chain queryability.

Constructor

LockData Struct

Functions

Events

ethers.js Example

const LOCK_ADDR = "0x..."; // IFRLock deployment address
const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";

const lockAbi = [
  "function lock(uint256 amount)",
  "function lockWithType(uint256 amount, bytes32 lockType)",
  "function unlock()",
  "function lockedBalance(address) view returns (uint256)",
  "function isLocked(address, uint256) view returns (bool)",
  "function lockInfo(address) view returns (uint256, uint256)",
  "function totalLocked() view returns (uint256)",
];

const tokenAbi = [
  "function approve(address spender, uint256 amount) returns (bool)",
];

const lockContract = new ethers.Contract(LOCK_ADDR, lockAbi, provider);
const token = new ethers.Contract(TOKEN_ADDR, tokenAbi, provider);

// Approve and lock 10,000 IFR
const amount = ethers.parseUnits("10000", 9);
await token.connect(signer).approve(LOCK_ADDR, amount);
await lockContract.connect(signer).lock(amount);

// Lock with a specific type (e.g. "premium" access)
const lockType = ethers.id("premium"); // keccak256("premium")
await lockContract.connect(signer).lockWithType(amount, lockType);

// Check if user qualifies (has >= 5000 IFR locked)
const minRequired = ethers.parseUnits("5000", 9);
const qualifies = await lockContract.isLocked(userAddr, minRequired);
console.log("Qualifies:", qualifies);

// Get lock details
const [lockedAmt, lockedAt] = await lockContract.lockInfo(userAddr);
console.log("Locked:", ethers.formatUnits(lockedAmt, 9), "IFR");
console.log("Since:", new Date(Number(lockedAt) * 1000));

// Unlock all tokens
await lockContract.connect(signer).unlock();

Manages the 40M IFR Builder Ecosystem Pool (4% of total supply). Two mechanisms: milestone-based unlocking (governance records milestones that unlock IFR allocations) and lock-triggered creator rewards (when a user locks IFR for a builder's product, the builder accrues a reward of lockAmount × rewardBps / 10000 from the pool). Rewards vest linearly over 6–12 months with optional cliff. Project policy (2026-10-03): the lock-triggered path is not used and no reward is active; pilot partners will be paid only for verified checkout redemptions through capped recordMilestone settlements.

Constructor

Admin Functions (Governance only)

Permissionless Functions

Key Design

• MUST be feeExempt on InfernoToken for correct claim transfers
• Governance-controlled parameters with enforced min/max bounds
• Annual emission cap resets every 365 days
• Milestone replay protection via milestoneDone mapping
• AuthorizedCaller whitelist: recordLockReward callable by admin OR whitelisted backend wallet
• Anti-double-count: each (wallet, partnerId) pair can only be rewarded once
• Algorithmic emission throttle (inactive on Mainnet): when setIFRLock is configured, reward rate scales from rewardBps down to MIN_REWARD_BPS (500) as global lock ratio rises from 1% to 50%; Mainnet ifrLock is unset (address(0)), so the flat rewardBps of 1500 is the configured contract parameter. Rewards are currently disabled (Lane 4 model B: pilot partners only, verified checkout redemptions, Governance-activated).
• SafeERC20 for all token transfers

Handles protocol-level fees on IFR swaps. Accepts optional EIP-712 discount vouchers issued by the Points Backend.

Deployment (Mainnet)

0x4807B77B2E25cD055DA42B09BA4d0aF9e580C60a — Etherscan

Key Parameters

Core Functions

EIP-712 Voucher Struct

DiscountVoucher {
  address user
  uint16  discountBps
  uint32  maxUses
  uint64  expiry
  uint256 nonce
}

Key Design Points

• Replay protection: usedNonces[user][nonce] = true after voucher use
• Fee cap: FEE_CAP_BPS = 25 is immutable — governance cannot exceed 0.25%
• Adapter whitelist: only governance-approved adapters can receive swap calls
• Pause: governance can halt all swaps in emergency
• Owned by Governance timelock

The IFR/WETH liquidity pair on Uniswap V2. This is not a custom contract but a standard UniswapV2Pair created by the factory during the LP pairing step. It holds ~195M IFR (from Treasury Safe + Community Safe, Plan B) paired with ETH, providing the primary trading market for the token. ✅ BootstrapVaultV3 FINALIZED 05.06.2026 23:51 UTC — Bootstrap ENDED — 0.030 ETH raised — LP live on Uniswap V2.

Addresses

Pool Details

ethers.js Example

// Mainnet LP Pair (IFR/WETH) — created by BootstrapVaultV3.finalise() on 05.06.2026
const PAIR_ADDR = "0xbE495E9c0d8cc2DCf95570cf95B63c4844dF31A0"; // Ethereum Mainnet
const pairAbi = [
  "function getReserves() view returns (uint112, uint112, uint32)",
  "function token0() view returns (address)",
  "function token1() view returns (address)",
  "function totalSupply() view returns (uint256)",
];

const pair = new ethers.Contract(PAIR_ADDR, pairAbi, provider);

// Read reserves
const [reserve0, reserve1] = await pair.getReserves();
const token0 = await pair.token0();

console.log("Token0:", token0);
console.log("Reserve0:", reserve0.toString());
console.log("Reserve1:", reserve1.toString());

On-chain registry for verified IFR builders and integration partners. Registration and removal controlled exclusively by Governance (Timelock). Used by the Telegram Bot for topic access control and for PartnerVault pilot-partner eligibility (rewards not active).

Key Functions

Categories

Each builder must be registered with one of 4 valid categories:

• creator — Content creators, community builders
• integration — DeFi integrations, aggregators
• tooling — Developer tools, analytics, dashboards
• dao — DAO contributors, governance delegates

Deployment

Integration

The Telegram Bot reads isBuilder(wallet) to determine Builder tier access (Dev & Builder topic). PartnerVault pilot partners are drawn from this registry (rewards not active).

Irrevocable token lock with 4 condition types (TIME_ONLY, PRICE_ONLY, TIME_OR_PRICE, TIME_AND_PRICE). Auto-unlock 30 days after condition met. P0 immutable after Bootstrap. Owner: Governance (TreasurySafe 3-of-5).

IFR lending against ETH collateral. Utilization-based interest (2–25%/month). Collateral: 200% initial, 150% margin call, 120% liquidation. Liquidator bonus: 5%. Interest split: 50% lender, 50% protocol. Owner: Governance (TreasurySafe 3-of-5).

Native-ETH fee execution controller. FeeRouterV1 is configured to send the ETH fee from routed swaps to this contract. When the controller holds at least its configured trigger amount, permissionless execute() attempts a 50/50 ETH allocation: buy IFR to BurnReserve and add IFR+ETH liquidity. Without an IFR balance, the LP half falls back to another buyback. Since Proposal #21 (05.10.2026) the 1% IFR pool fee also goes to this contract; the IFR previously held by FeeRouterV1 was recovered to the Treasury Safe on 07.10.2026 (Proposals #22/#23).