> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ifalabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Answers to the most frequently asked questions about IFÁ Labs — what it is, how it works, how to integrate it, and where to get help.

Answers to the questions developers and protocol teams ask most often. If your question is not covered here, reach out via any [support channel](/get-help).

***

## General

<AccordionGroup>
  <Accordion title="What is IFÁ Labs?">
    IFÁ Labs is a decentralized, multi-chain oracle network that delivers trustless, manipulation-resistant price feeds for stablecoins — directly on-chain, with no off-chain dependencies for price reads.

    Unlike general-purpose oracles built around volatile assets like BTC and ETH, IFÁ Labs is purpose-built for stablecoins — including both global assets (USDT, USDC) and emerging market local stablecoins (cNGN in Nigeria, ZARP in South Africa, BRZ in Brazil).

    See [What is IFÁ Labs?](/what-is-ifa-labs) for the full overview.
  </Accordion>

  <Accordion title="How is IFÁ Labs different from Chainlink or Pyth?">
    Chainlink and Pyth are excellent general-purpose oracle networks. IFÁ Labs is not trying to replace them — it specializes where they generalize.

    The key differences:

    * **Local stablecoin coverage.** cNGN, ZARP, and BRZ have no reliable dedicated feeds on Chainlink or Pyth. IFÁ Labs is currently the only oracle providing trustless on-chain pricing for these assets.
    * **Aggregation logic tuned for stablecoins.** General-purpose deviation thresholds are calibrated for volatile assets. IFÁ Labs uses tight, peg-aware thresholds that catch meaningful stablecoin moves without noise.
    * **Regional data sources.** Accurate pricing for emerging market stablecoins requires data from local exchanges and forex providers. IFÁ Labs integrates these directly.
    * **Fully on-chain reads.** Price reads require no transaction, no gas, and no off-chain request — a single `view` call on EVM or a shared object query on Sui returns the current price.

    Many protocols use both: IFÁ Labs for stablecoin feeds, Chainlink or Pyth for volatile assets. See [Key Differentiators](/key-differentiators-vs-chainlink-pyth) for the full comparison.
  </Accordion>

  <Accordion title="Is IFÁ Labs fully on-chain?">
    Yes. On EVM chains, all price data is stored in audited smart contracts and is readable via public `view` functions. On Sui, prices are stored in a shared `IfaPriceFeed` object and are readable by any Move module or TypeScript client.

    In both cases there is no off-chain API, no middleware, and no centralized component in the read path. Price reads cost no gas when called externally. Any address can read any feed at any time without permission, API keys, or fees.
  </Accordion>

  <Accordion title="Which chains does IFÁ Labs support?">
    Currently live:

    * **Base Mainnet** — primary production deployment (EVM)
    * **Base Sepolia** — recommended EVM testnet
    * **AssetChain Testnet** — RWA-focused EVM ecosystem
    * **Sui Testnet** — native Move deployment on Sui

    Planned: Sui Mainnet, AssetChain Mainnet, Solana, Optimism, Arbitrum, Polygon zkEVM, and additional EVM L2s based on ecosystem demand.

    See [Supported Chains & Roadmap](/supported-chains-and-roadmap) for full details and timelines.
  </Accordion>

  <Accordion title="Which stablecoins does IFÁ Labs support?">
    Currently supported:

    | Asset                         | Symbol   | Category        |
    | ----------------------------- | -------- | --------------- |
    | Tether                        | USDT/USD | Global          |
    | USD Coin                      | USDC/USD | Global          |
    | Nigerian Naira Stablecoin     | CNGN/USD | Emerging Market |
    | South African Rand Stablecoin | ZARP/USD | Emerging Market |
    | Brazilian Real Stablecoin     | BRZ/USD  | Emerging Market |
    | Ethereum                      | ETH/USD  | Reference Asset |

    All feeds are available across every supported network — EVM and Sui. New assets are added on a rolling basis. See [Supported Assets](/supported-assets) for the complete list including asset IDs.
  </Accordion>

  <Accordion title="Is IFÁ Labs free to use?">
    Reading prices from IFÁ Labs is completely free. Price reads are `view` calls on EVM and read-only shared object queries on Sui — neither costs gas and neither requires a subscription, API key, or fee payment.

    The only cost is standard network gas if you deploy your own contract that consumes IFÁ Labs feeds and writes data to your own contract's storage.
  </Accordion>

  <Accordion title="Is there a way to swap stablecoins using IFÁ Labs?">
    Yes. The **IFÁ Labs Swap Contract** is a live heterogeneous liquidity pool on Sui Testnet that uses the oracle directly for pricing — supporting deposits, withdrawals, swaps, and dust sweeping across SUI, CNGN, ZARP, and other listed assets.

    See [Sui Swap Contract](/sui-swap-overview) for the full overview and integration guide.
  </Accordion>
</AccordionGroup>

***

## Integration

<AccordionGroup>
  <Accordion title="How do I read a price from IFÁ Labs in Solidity?">
    Call `getAssetInfo` on the oracle contract with the asset's `bytes32` ID:

    ```solidity theme={null}
        import "ifapricefeed-interface/IIfaPriceFeed.sol";

        IIfaPriceFeed constant ORACLE =
            IIfaPriceFeed(0xA9F17344689C2c2328F94464998db1d3e35B80dC); // Base Mainnet

        bytes32 constant USDT_ID =
            0x6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d;

        function getUSDTPrice() external view returns (uint256) {
            (IIfaPriceFeed.PriceFeed memory info, bool exists) =
                ORACLE.getAssetInfo(USDT_ID);

            require(exists, "Not supported");
            require(block.timestamp - info.lastUpdateTime <= 3600, "Stale");

            return uint256(info.price) / 1e18; // human-readable price
        }
    ```

    See [Read Latest Price](/read-latest-price) for full examples including batch reads and derived pairs.
  </Accordion>

  <Accordion title="How do I read a price from IFÁ Labs in Sui Move?">
    Pass the shared `IfaPriceFeed` object by reference and call `get_asset_info`:

    ```move theme={null}
        use ifa_oracle::price_feed::{Self, IfaPriceFeed};
        use ifa_oracle::bytes32;

        public fun get_usdt_price(feed: &IfaPriceFeed): u256 {
            let asset_id = bytes32::new(
                x"6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d"
            );

            let (price_feed, exists) = price_feed::get_asset_info(feed, asset_id);
            assert!(exists, 0);

            // Sui uses positive decimals — divide by 10^decimal
            // For decimal = 18: divide by 1_000_000_000_000_000_000
            price_feed::price(price_feed)
        }
    ```

    The Feed Object ID on Sui Testnet is `0x5d2728b862de08de767e4f8841a38c9452d951c0602e77fc47bfbb3ab03f33f0`. Pass it as the `feed` argument in your transaction. See the [Sui Integration Guide](/sui-read-latest-price) for full examples.
  </Accordion>

  <Accordion title="What are asset IDs and how are they generated?">
    Asset IDs are fixed 32-byte identifiers generated by hashing the asset symbol string with `keccak256`:

    ```solidity theme={null}
        bytes32 assetId = keccak256(abi.encodePacked("USDT/USD"));
    ```

    The symbol string format is uppercase with a forward slash: `"SYMBOL/USD"`. The same underlying 32-byte value works on every IFÁ Labs deployment — no remapping between networks.

    On EVM the ID is used as a `bytes32` hex string. On Sui it is passed as a `vector<u8>` — same bytes, different format. You can independently verify any asset ID by computing the hash yourself and comparing against the published value. See [Working with Asset IDs](/working-with-asset-ids) for full details.
  </Accordion>

  <Accordion title="How do I convert the raw price to a human-readable value?">
    The conversion formula differs between EVM and Sui:

    **EVM** — `decimal` is negative (e.g. `-18`). Divide by `10^(-decimal)`:

    ```solidity theme={null}
        // Solidity
        uint256 humanPrice = uint256(info.price) / 1e18;
    ```

    ```javascript theme={null}
        // JavaScript (EVM)
        const humanPrice = ethers.formatUnits(info.price, -info.decimal);
    ```

    **Sui** — `decimal` is positive (e.g. `18`). Divide by `10^decimal`:

    ```move theme={null}
        // Move
        // price = 1_000_000_000_000_000_000, decimal = 18 → $1.00
        // Divide price by pow(10, decimal) for human-readable value
    ```

    ```typescript theme={null}
        // TypeScript (Sui)
        const humanPrice = Number(price) / Math.pow(10, decimal);
    ```

    Always read `decimal` dynamically rather than hardcoding — future assets may use different precision. See [Decimal Precision & Formatting](/decimal-precision-and-formatting) for full conversion guidance.
  </Accordion>

  <Accordion title="What staleness threshold should I use?">
    Set `MAX_PRICE_AGE` to at least 1.5× the heartbeat interval for each asset:

    | Asset    | Heartbeat | Minimum MAX\_PRICE\_AGE |
    | -------- | --------- | ----------------------- |
    | USDT/USD | 1 hour    | 5,400s (90 min)         |
    | USDC/USD | 1 hour    | 5,400s (90 min)         |
    | CNGN/USD | 2 hours   | 10,800s (3 hrs)         |
    | ZARP/USD | 2 hours   | 10,800s (3 hrs)         |
    | BRZ/USD  | 2 hours   | 10,800s (3 hrs)         |
    | ETH/USD  | 1 hour    | 5,400s (90 min)         |

    The 1.5× buffer accounts for heartbeat jitter — minor delays in relayer submission that mean heartbeats don't fire at exactly regular intervals.

    On Sui, the contract exposes a built-in helper: `price_feed::is_fresh(price_feed, current_time, max_age)` returns a `bool` directly — you do not need to implement the subtraction check yourself.

    For production deployments, run the cadence analysis script in [Price Appears Stale](/price-appears-stale) to calibrate thresholds from real on-chain data rather than documentation estimates.
  </Accordion>

  <Accordion title="Can I get prices for multiple assets in one call?">
    Yes, on both EVM and Sui.

    **EVM** — use `getAssetsInfo` with an array of asset IDs:

    ```solidity theme={null}
        bytes32[] memory ids = new bytes32[](3);
        ids[0] = USDT_ASSET_ID;
        ids[1] = CNGN_ASSET_ID;
        ids[2] = ZARP_ASSET_ID;

        (IIfaPriceFeed.PriceFeed[] memory infos, bool[] memory exists) =
            ORACLE.getAssetsInfo(ids);
    ```

    **Sui** — use `get_assets_info` with a `vector<Bytes32>`:

    ```move theme={null}
        let (price_feeds, exists) = price_feed::get_assets_info(feed, asset_indexes);
    ```

    One call is significantly cheaper than N consecutive single-asset calls on both chains. See [Gas Optimization Tips](/gas-optimization-tips) for EVM, and the [Sui Integration Guide](/sui-read-latest-price) for Move.
  </Accordion>

  <Accordion title="How do I price CNGN against USDT — or any asset against another?">
    Use the derived pair functions. IFÁ Labs computes cross-asset prices on-chain using the two underlying USD feeds as intermediates.

    **EVM:**

    ```solidity theme={null}
        IIfaPriceFeed.DerivedPair memory pair = ORACLE.getPairbyId(
            CNGN_ASSET_ID,
            USDT_ASSET_ID,
            IIfaPriceFeed.PairDirection.Forward
        );
    ```

    **Sui:**

    ```move theme={null}
        let pair = price_feed::get_pair_by_id(feed, cngn_id, usdt_id, 0); // 0 = forward
    ```

    On Sui, derived pair results always use `decimal = 30` with `derived_price` scaled by `10^30`. This is fixed — not per-asset.

    Any combination of the six supported assets is computable as a derived pair. See [Function Reference](/function-reference) for the EVM API, or the [Sui Integration Guide](/sui-read-latest-price) for Move.

    <Warning>
      On Sui, derived pair functions abort if either underlying asset does not exist — they do not return a false flag. Always verify both assets exist with `get_asset_info` before calling pair functions on Sui.
    </Warning>
  </Accordion>

  <Accordion title="Do I need a wallet or ETH to read prices?">
    No. On EVM, price reads are `view` calls — no wallet, no ETH, no transaction required. On Sui, price reads use `devInspectTransactionBlock` — no SUI tokens or signing required.

    You only need tokens if you are deploying your own contracts that consume IFÁ Labs feeds.
  </Accordion>

  <Accordion title="Can I use IFÁ Labs from JavaScript without writing Solidity?">
    Yes. On EVM, use ethers.js or viem:

    ```javascript theme={null}
        const { ethers } = require("ethers");

        const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
        const oracle   = new ethers.Contract(
          "0xA9F17344689C2c2328F94464998db1d3e35B80dC",
          ["function getAssetInfo(bytes32) view returns ((int256 price, int8 decimal, uint256 lastUpdateTime), bool exists)"],
          provider
        );

        const [info, exists] = await oracle.getAssetInfo(
          "0x6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d"
        );

        const price = ethers.formatUnits(info.price, -info.decimal);
        console.log(`USDT/USD: $${price}`);
    ```

    On Sui, use the Sui TypeScript SDK with `devInspectTransactionBlock`. See the [Sui Integration Guide](/sui-read-latest-price) for the full pattern.

    See [Get Your First Price](/get-your-first-price-on-chain) for full EVM off-chain examples in JavaScript, Python, and via Basescan.
  </Accordion>
</AccordionGroup>

***

## Security

<AccordionGroup>
  <Accordion title="Have the IFÁ Labs contracts been audited?">
    Yes. All EVM oracle contracts were professionally audited by A\&D Forensics in July 2025.

    Audit result: no critical or high severity findings. Seven findings total — five low severity, two informational. All seven were resolved before mainnet deployment.

    The full audit summary is at [AdForensics Audit Summary](/adforensics-audit-summary). The complete report is available on request from [support@ifalabs.com](mailto:support@ifalabs.com) and in the [GitHub repository](https://github.com/IFA-Labs/oracle_contract).

    The Sui Move contracts (oracle and swap) are currently on testnet. A formal audit will be completed before either reaches mainnet.
  </Accordion>

  <Accordion title="Can IFÁ Labs modify or pause price feeds?">
    On EVM, the oracle contracts are immutable — no upgrade mechanism, no proxy pattern, and no admin keys that can modify stored prices or pause feed updates. Once a price is written to contract storage by an authorized relayer, it remains there until the next legitimate update.

    On Sui, the `IfaPriceFeed` shared object is write-protected — only the authorized `IfaPriceFeedVerifier` can submit updates, and only the relayer address configured in the verifier can call `submit_price_feed`. The `AdminCap` controls verifier configuration but cannot directly alter stored prices.

    IFÁ Labs cannot retroactively alter historical prices or freeze a feed on either chain.
  </Accordion>

  <Accordion title="What happens if a relayer submits a wrong price?">
    Multiple layers of protection prevent this:

    * Prices are aggregated from multiple independent sources before submission — no single source determines the output
    * Outlier detection filters anomalous data points before consensus calculation
    * A weighted median algorithm makes the final price resistant to minority manipulation
    * Zero-price and peg bounds validation reject obviously wrong values before on-chain submission
    * Decentralized relayers independently verify the aggregated price before signing
    * On Sui, the verifier contract additionally rejects prices with zero value or zero timestamps, and ignores submissions with older timestamps than the current stored value

    See [Data Integrity Mechanisms](/data-integrity-mechanisms) for the full seven-layer defense architecture.
  </Accordion>

  <Accordion title="How do I verify IFÁ Labs prices independently?">
    Five methods are available — all using public data with no trust in IFÁ Labs required:

    1. Read the current on-chain price and compare against external market sources
    2. Independently compute any asset ID using `keccak256` and verify it matches the published value
    3. Query historical `PriceUpdated` events (EVM) or `AssetInfoSet` events (Sui) and verify update cadence and price progression
    4. Compare prices across chains to verify cross-chain consistency
    5. Clone the audited commit and compare compiled bytecode against the deployed contract

    Full instructions for all five methods: [Verification Proofs](/verification-proofs).
  </Accordion>

  <Accordion title="How do I report a security vulnerability?">
    Email [support@ifalabs.com](mailto:support@ifalabs.com) with a description of the issue, reproduction steps, and your assessment of severity. Do not disclose security issues publicly before coordinating with IFÁ Labs.

    We acknowledge all reports within 48 hours. See [Report a Vulnerability](/report-a-vulnerability) for the full responsible disclosure policy.
  </Accordion>
</AccordionGroup>

***

## MCP Server

<AccordionGroup>
  <Accordion title="What is the IFÁ Labs MCP Server?">
    The IFÁ Labs MCP Server exposes the full oracle infrastructure through the Model Context Protocol — an open standard that lets AI assistants and coding tools call external tools and data sources directly.

    In practice: you can ask Claude, Cursor, Windsurf, TRAE, or any MCP-compatible client for live stablecoin prices, asset IDs, feed freshness checks, and network configuration — and get verified on-chain data back in seconds, without leaving your editor or AI assistant.

    See [What is the IFÁ Labs MCP Server?](/what-is-the-ifa-labs-mcp-server) for full details.
  </Accordion>

  <Accordion title="How do I install the MCP server?">
    ```bash theme={null}
        npm install -g @ifalabs/mcp-server
    ```

    Then add it to your MCP client's configuration. For Claude Desktop:

    ```json theme={null}
        {
          "mcpServers": {
            "ifalabs": {
              "command": "ifa-mcp",
              "args": ["--network", "base-mainnet"]
            }
          }
        }
    ```

    Full installation instructions for every supported client: [MCP Server Installation & Setup](/installation-and-setup).
  </Accordion>

  <Accordion title="Which MCP clients does IFÁ Labs support?">
    Any MCP-compatible client. Officially tested and documented:

    * Claude Desktop
    * Cursor
    * Windsurf
    * TRAE
    * Zed
    * Continue
    * LangChain, CrewAI, AutoGen (programmatic)

    See [MCP Client Compatibility](/mcp-client-compatibility) for client-specific configuration and known limitations.
  </Accordion>

  <Accordion title="Does the MCP server cost anything to use?">
    No. The MCP server reads from the same free, public oracle contracts as any other integration. No API keys, no subscription, and no gas required.
  </Accordion>
</AccordionGroup>

***

## Assets and Feeds

<AccordionGroup>
  <Accordion title="How do I request a new stablecoin feed?">
    Contact IFÁ Labs with the following:

    * Token contract address on all relevant chains
    * Backing mechanism and reserve proof or documentation
    * Current daily trading volume across all venues
    * The protocol or use case driving the request

    Reach out via [support@ifalabs.com](mailto:support@ifalabs.com), [Telegram](https://t.me/ifalabs), or [GitHub Issues](https://github.com/IFA-Labs/oracle_contract/issues).

    IFÁ Labs prioritizes emerging market stablecoins in Africa, Latin America, and Southeast Asia. New assets are reviewed and deployed on a rolling basis.
  </Accordion>

  <Accordion title="Why is my price feed showing as stale?">
    The most likely cause is that your `MAX_PRICE_AGE` threshold is tighter than the asset's natural update cadence.

    During stable market conditions, IFÁ Labs feeds update only when the price moves beyond the deviation threshold — not continuously. A feed that appears stale by your threshold may be accurate and working correctly.

    Set `MAX_PRICE_AGE` to at least 1.5× the heartbeat interval for the asset. Then run the cadence analysis script in [Price Appears Stale](/price-appears-stale) to calibrate from real on-chain data.

    If the feed age significantly exceeds the heartbeat interval across all assets simultaneously, a relayer issue may be affecting the deployment. Check the [Telegram](https://t.me/ifalabs) for incident announcements.
  </Accordion>

  <Accordion title="Are asset IDs the same across all networks?">
    Yes — the underlying 32-byte value is identical across every network, including Sui.

    The format differs between chain types:

    * **EVM** — used as a `bytes32` hex string: `0x6ca0cef6...`
    * **Sui** — passed as a `vector<u8>`: `x"6ca0cef6..."` in Move, or a byte array in TypeScript

    The only thing that changes between networks is the contract address (EVM) or object ID (Sui). See [Contract Addresses](/contract-addresses) for the full reference.
  </Accordion>

  <Accordion title="What is ETH/USD doing in a stablecoin oracle?">
    ETH/USD is included as a reference asset to enable derived pair calculations between stablecoins and ETH — for example, pricing USDC in ETH terms or ETH in CNGN terms.

    IFÁ Labs is stablecoin-first. ETH is not a primary feed target — it is there to make cross-asset pricing more flexible for protocols that need it. Do not apply stablecoin-specific checks (like a \$1.00 peg deviation guard) to ETH/USD.
  </Accordion>
</AccordionGroup>

***

## Sui

<AccordionGroup>
  <Accordion title="How is the Sui integration different from EVM?">
    Several things are different on Sui:

    * **Shared objects instead of contract addresses.** You pass the `IfaPriceFeed` object by reference in transactions — there is no contract address to call.
    * **Positive decimal convention.** Sui uses `u8` for the decimal field. `18` means divide by `10^18` — the opposite sign from EVM's `-18`.
    * **Derived pair decimal is always 30.** All derived pair results on Sui have `decimal = 30` and `derived_price` scaled by `10^30`.
    * **Asset IDs as `vector<u8>`.** Same 32-byte values as EVM — but passed without the `0x` prefix using Sui's hex literal syntax `x"..."`.
    * **Built-in `is_fresh` helper.** The Sui contract exposes `price_feed::is_fresh(price_feed, current_time, max_age): bool` — no need to implement the staleness check yourself.
    * **Derived pair functions abort on missing assets.** On EVM, missing assets return `exists = false`. On Sui, they abort. Always check both assets exist before calling pair functions.

    See the [Sui Integration Guide](/sui-read-latest-price) for the full pattern.
  </Accordion>

  <Accordion title="Where do I get testnet SUI and WAL for development?">
    Two options:

    * **Official Sui Faucet** — [faucet.sui.io](https://faucet.sui.io) for testnet SUI
    * **IFÁ Labs Faucet** — claim testnet SUI and WAL tokens directly from the IFÁ Labs multi-token faucet deployed on Sui Testnet. See the [Testnet Faucet](/testnet-faucet) page for claim instructions.
  </Accordion>

  <Accordion title="What are the Sui Testnet object IDs?">
    | Object                 | ID                                                                   |
    | ---------------------- | -------------------------------------------------------------------- |
    | **Package ID**         | `0x99847c953ee11ca57b6d602494c914d7d82a2d42c4c8a80307331fead5b22c4a` |
    | **Feed Object ID**     | `0x5d2728b862de08de767e4f8841a38c9452d951c0602e77fc47bfbb3ab03f33f0` |
    | **Verifier Object ID** | `0x028e5df554ac7d253a132c60bcd13cf32bea9eb8c81d04d685c2a31299fbe43b` |

    When reading prices, pass the **Feed Object ID**. The Package ID is only needed when importing `ifa_oracle` as a dependency in your own Move package.

    <Warning>
      These object IDs were updated after a redeployment of the oracle package. If you previously saved different IDs, they are now stale — always cross-check against [Contract Addresses](/contract-addresses) before integrating.
    </Warning>

    See [Contract Addresses](/contract-addresses) for the full reference.
  </Accordion>

  <Accordion title="Is there a swap contract on Sui?">
    Yes. The **IFÁ Labs Swap Contract** is a live heterogeneous liquidity pool deployed on Sui Testnet, priced directly by the IFÁ Labs oracle. It supports liquidity deposits and withdrawals, asset-to-asset swaps, and dust sweeping into a target asset across SUI, CNGN, ZARP, and other listed tokens.

    See [Sui Swap Contract](/sui-swap-overview) for the full overview, pool details, and integration guide.
  </Accordion>
</AccordionGroup>

***

## Community and Contribution

<AccordionGroup>
  <Accordion title="How do I stay updated on new deployments and assets?">
    Three channels:

    * **X:** [@ifalabs](https://x.com/ifalabs) — deployment announcements, new assets, ecosystem news
    * **Telegram:** [t.me/ifalabs](https://t.me/ifalabs) — real-time updates and incident announcements
    * **GitHub:** [Watch the repository](https://github.com/IFA-Labs/oracle_contract) — contract changes and releases

    The [Changelog](/changelog) is updated for every significant release.
  </Accordion>

  <Accordion title="Can I contribute to IFÁ Labs?">
    Yes. Pull requests are welcome for bug fixes, test coverage, gas optimizations, documentation improvements, and new integration examples.

    See [GitHub & Bug Reports](/github-and-bug-reports) for the full contribution workflow, repository structure, and contribution areas.
  </Accordion>

  <Accordion title="Is there a bug bounty program?">
    A formal bug bounty program is under development. Until it launches, critical and high severity findings submitted through responsible disclosure will be reviewed for discretionary rewards based on impact and report quality.

    See [Report a Vulnerability](/report-a-vulnerability) for the current disclosure policy and contact channels.
  </Accordion>
</AccordionGroup>

***

## Still Have Questions?

<CardGroup cols={2}>
  <Card title="Get Help" icon="message" href="/get-help">
    Every support channel and what each one is best for.
  </Card>

  <Card title="GitHub & Bug Reports" icon="github" href="/github-and-bug-reports">
    Report bugs, request features, and contribute to IFÁ Labs.
  </Card>
</CardGroup>