import { type Address } from 'viem';
/**
 * Per-chain addresses of the Liquidity Launcher stack. Keyed by numeric chain id.
 */
export interface LauncherAddresses {
    /** LiquidityLauncher singleton (the `multicall` entry point a wallet calls). */
    liquidityLauncher: Address;
    /** LBPStrategy singleton (passed as `Distribution.strategy`; owns `registeredPoolIds`). */
    lbpStrategy: Address;
    /** TokenSplitter strategy: routes the creator's un-auctioned portion (returned supply). */
    tokenSplitter: Address;
    /** ContinuousClearingAuction factory. */
    ccaFactory: Address;
    /** Permit2 (canonical address on every chain). */
    permit2: Address;
    /**
     * UniversalRouterStrategy singleton: the launcher-gated strategy that runs a caller-supplied
     * Universal Router route, so a launch and a creator buy fit in one `multicall`. Passed as the
     * `strategy` of `distributeWithNative` (native input) or of a `Distribution` (ERC-20 input).
     * Optional — deployed only on chains that carry the liquidity-launcher #223/#227 launcher.
     */
    universalRouterStrategy?: Address;
    /**
     * Registered token factories the new-token path may target. Ethereum-style chains carry a uERC20
     * factory; superchains carry a super-uERC20 factory (mainnet has both). Both are optional: chains
     * that deploy neither support launches with pre-existing tokens only ({@link selectTokenFactory}
     * returns `undefined` there).
     */
    uerc20Factory?: Address;
    usuperc20Factory?: Address;
    /**
     * Canonical Uniswap v4 PositionManager (source: sdk-core `v4PositionManagerAddress`). Liquidity-lock
     * recipients hold migrated LP positions via this. Optional: lock is only offered where it's set.
     */
    positionManager?: Address;
}
/** All deployed launcher stacks, keyed by numeric chain id. */
export declare const LAUNCHER_ADDRESSES: Partial<Record<number, LauncherAddresses>>;
/** Returns the launch addresses for a chain, or `undefined` if the stack is not deployed there. */
export declare function getLauncherAddresses(chainId: number): LauncherAddresses | undefined;
/** TickDataLens for v1 (TWA) auctions. CREATE2 — same address on every supported chain. */
export declare const TICK_DATA_LENS_V1: Address;
/** TickDataLens for v2 (CCA) auctions. CREATE2 — same address on every supported chain. */
export declare const TICK_DATA_LENS_V2: Address;
/** One historical auction-factory deployment, paired with the lens that reads its auctions. */
export interface AuctionFactoryDeployment {
    /** The auction factory (CREATE2 — same address on every chain it is deployed to). */
    factory: Address;
    /**
     * The TickDataLens that can read auctions created by this factory. The lens is 1:1 with the
     * auction implementation version: v1 (TWA) auctions can only be read by the v1 lens, v2 (CCA)
     * auctions by the v2 lens. Both lenses return the same tuple shape, so one ABI decodes either.
     */
    tickDataLens: Address;
    /** Human-readable deployment tag (not an on-chain value). */
    description: string;
}
/**
 * Every auction factory ever deployed — current and historical — each paired with its TickDataLens.
 * Append-only: indexed auctions permanently reference the factory that created them, so when a
 * factory is redeployed the new entry is added and the old ones are kept. Downstream indexers
 * resolve a stored factory address through this registry instead of hardcoding their own map, so a
 * redeploy only requires bumping this package.
 */
export declare const AUCTION_FACTORY_DEPLOYMENTS: readonly AuctionFactoryDeployment[];
/**
 * Factory address (lowercased) → TickDataLens, derived from {@link AUCTION_FACTORY_DEPLOYMENTS}.
 * Keys are lowercased so lookups are case-insensitive regardless of how the caller stored the
 * factory address; prefer {@link getTickDataLensForFactory}, which normalizes for you.
 */
export declare const TICK_DATA_LENS_BY_FACTORY: ReadonlyMap<string, Address>;
/**
 * Resolves the TickDataLens that reads auctions created by `factoryAddress` (case-insensitive).
 * Returns `undefined` for a factory not in {@link AUCTION_FACTORY_DEPLOYMENTS} — callers with
 * pre-registry rows (or a null stored factory) typically fall back to {@link TICK_DATA_LENS_V1},
 * since every auction indexed before factories were recorded is a v1 auction.
 */
export declare function getTickDataLensForFactory(factoryAddress: string): Address | undefined;
/** FeeSplitter splits are expressed in basis points summing to this denominator per currency side. */
export declare const FEE_SPLIT_BPS_DENOMINATOR = 10000;
/**
 * One Instant Launch strategy deployment: an InstantLaunchStrategy instance plus the immutable
 * contracts wired into it at construction. The creator-fee variant is a deployment property, not a
 * launch parameter — enabling/disabling creator fees means launching through a different strategy.
 */
export interface InstantLaunchDeployment {
    /** Chain the instance is deployed to. */
    chainId: number;
    /** The InstantLaunchStrategy instance (`Distribution.strategy` of a launch). */
    strategy: Address;
    /**
     * The strategy's immutable FeeSplitter — the permanent custodian of every launch LP NFT this
     * strategy mints (`TokenLaunched.finalPositionRecipient`) and the fee distributor for it.
     */
    feeSplitter: Address;
    /**
     * Whether this instance carries a creator-fee share: `true` when the strategy's immutable
     * `beneficiaryVault` is set (each launch registers its `feeBeneficiary`, minting the transferable
     * beneficiary ERC721), `false` when it is zero (registration skipped; the config beneficiary is
     * ignored and 100% of fees autocompound).
     */
    creatorFeesEnabled: boolean;
    /**
     * Share of each `FeesCollected` **native (ETH)** amount the splitter forwards to the beneficiary
     * vault, in bps of {@link FEE_SPLIT_BPS_DENOMINATOR}. The creator's accrual rate: 4000 on the
     * fees-on splitter, 0 on the fees-off one. The remainder autocompounds.
     */
    creatorFeeNativeBps: number;
    /** Share of each `FeesCollected` **token** amount forwarded to the vault, in bps (0 on every current deploy). */
    creatorFeeTokenBps: number;
    /**
     * The strategy's compile-time pool tick spacing (`TICK_SPACING`) — the spacing every pool this
     * generation minted has forever. 25 from the 2026-08-05 full redeploy onward, 60 on every earlier
     * generation.
     */
    tickSpacing: number;
    /** The strategy's immutable `initialTick` — the aligned tick the launch pool opens at. */
    initialTick: number;
    /**
     * The strategy's compile-time lower tick of every launch position (`MIN_LAUNCH_TICK`).
     * -160,100 from the 2026-08-05 full redeploy onward, -208,980 (the OZ H01 floor) on every
     * earlier generation.
     */
    minLaunchTick: number;
    /** Human-readable deployment tag (not an on-chain value). */
    description: string;
    /** Block the strategy was deployed at, when recorded (indexer start height). */
    deployedAtBlock?: number;
}
/**
 * The per-chain Instant Launch singletons shared by every strategy variant on that chain.
 */
export interface InstantLaunchChainContracts {
    /** LiquidityLauncher — the `multicall(createToken, distributeToken)` entrypoint (same registry value as {@link LauncherAddresses.liquidityLauncher}). */
    liquidityLauncher: Address;
    /**
     * UERC20BeneficiaryVault — registers each fees-on launch's beneficiary as a transferable ERC721
     * and vaults the creator's share of split fees. Also lets the creator of a launcher-created
     * uERC20 claim unregistered positions via the token's graffiti. Optional: omitted on chains with
     * no fees-on FeeSplitter (Arc).
     */
    beneficiaryVault?: Address;
    /**
     * CompoundingClaimRecipient — the protocol/autocompound split recipient of the chain's current
     * FeeSplitters. Its `Claimed` events prove same-transaction liquidity compounding. Optional:
     * omitted on chains whose current splitters do not compound (Arc — buyback-and-burn).
     */
    compoundingClaimRecipient?: Address;
    /**
     * BuybackAndBurnRecipient — the non-creator split recipient of the buyback-and-burn FeeSplitters
     * (Arc's current generation). Optional: only where such splitters are deployed.
     */
    buybackAndBurnRecipient?: Address;
}
/**
 * Every Instant Launch strategy deployment — current and historical. **Append-only**: indexed
 * launches permanently reference the strategy that created them, so a redeploy appends new entries
 * and keeps the old ones; downstream indexers resolve a stored strategy address through
 * {@link getInstantLaunchDeployment} instead of hardcoding their own map, and transaction builders
 * select the current variant via {@link getInstantLaunchStrategy}. A contract redeploy is then just
 * an SDK release. The current deployment for a (chain, variant) pair is the **last** matching entry.
 */
export declare const INSTANT_LAUNCH_DEPLOYMENTS: readonly InstantLaunchDeployment[];
/** The per-chain Instant Launch singleton contracts, keyed by numeric chain id. */
export declare const INSTANT_LAUNCH_CONTRACTS: Partial<Record<number, InstantLaunchChainContracts>>;
/**
 * Strategy address (lowercased) → deployment, derived from {@link INSTANT_LAUNCH_DEPLOYMENTS}.
 * Keys are lowercased so lookups are case-insensitive regardless of how the caller stored the
 * strategy address; prefer {@link getInstantLaunchDeployment}, which normalizes for you.
 */
export declare const INSTANT_LAUNCH_DEPLOYMENT_BY_STRATEGY: ReadonlyMap<string, InstantLaunchDeployment>;
/** Every Instant Launch strategy deployment on `chainId` (empty where none is deployed). */
export declare function getInstantLaunchDeployments(chainId: number): readonly InstantLaunchDeployment[];
/**
 * Selects the **current** strategy deployment for a chain and creator-fee variant — what a
 * transaction builder launches through. Returns the last matching registry entry (the registry is
 * append-only, so the newest deployment of a variant wins), or `undefined` where the variant is not
 * deployed.
 */
export declare function getInstantLaunchStrategy(chainId: number, options: {
    creatorFeesEnabled: boolean;
}): InstantLaunchDeployment | undefined;
/**
 * Reverse lookup for indexers/attribution: resolves a stored strategy address (case-insensitive) to
 * its deployment — chain, FeeSplitter, creator-fee variant and split bps. Returns `undefined` for a
 * strategy not in {@link INSTANT_LAUNCH_DEPLOYMENTS}.
 */
export declare function getInstantLaunchDeployment(strategyAddress: string): InstantLaunchDeployment | undefined;
/** The per-chain Instant Launch singletons, or `undefined` where Instant Launch is not deployed. */
export declare function getInstantLaunchContracts(chainId: number): InstantLaunchChainContracts | undefined;
/**
 * The current creator-fees position recipient per chain: the fees-enabled FeeSplitter from
 * {@link INSTANT_LAUNCH_DEPLOYMENTS} (the `creatorFeesEnabled: true` entry; last one wins where the
 * append-only registry carries several). Derived from the registry, so a splitter redeploy only
 * requires appending a registry entry. Prefer {@link getCreatorFeesPositionRecipient}.
 */
export declare const CREATOR_FEES_POSITION_RECIPIENTS: Partial<Record<number, Address>>;
/**
 * The position recipient that opts an auction / crowd launch into creator fees on `chainId` — set it
 * as the launch's `MigratorParameters.positionRecipient` (in place of a per-launch lock-recipient
 * contract). It is the **fees-enabled** FeeSplitter of the chain's current creator-fees deployment
 * ({@link getInstantLaunchStrategy} with `creatorFeesEnabled: true` — the same splitter Instant
 * Launch mints its positions to).
 *
 * What sending the migrated LP position there means:
 *  - the splitter forwards the creator's share of each collected **native (ETH)** fee amount
 *    ({@link InstantLaunchDeployment.creatorFeeNativeBps} — 40% on the current deploy) to the
 *    chain's BeneficiaryVault, where the token's creator — the `createToken` caller, proven by the
 *    token's graffiti — claims it post-migration;
 *  - the remainder (60% native + 100% of the token side) auto-compounds into the position via the
 *    chain's compounding claim recipient;
 *  - custody is **permanent**: the splitter has no code path that transfers positions out, so the
 *    liquidity is locked forever by construction (no timelock involved).
 *
 * Only the `creatorFeesEnabled: true` splitter qualifies — the fees-off splitter never routes
 * anything to the vault, so it is not a creator-fees recipient (see
 * {@link isCreatorFeesPositionRecipient}); its own accessor is
 * {@link getAutocompoundPositionRecipient}. Returns `undefined` where the chain has no creator-fees
 * deployment.
 */
export declare function getCreatorFeesPositionRecipient(chainId: number): Address | undefined;
/**
 * Whether `recipient` is a creator-fees position recipient on `chainId`: the fees-enabled
 * FeeSplitter of any registry deployment for the chain — current or historical, since the registry
 * is append-only and indexed launches permanently reference the splitter they migrated to.
 * Case-insensitive. This is the classifier-side counterpart of
 * {@link getCreatorFeesPositionRecipient}: a launch whose `MigratorParameters.positionRecipient`
 * matches is parked at the splitter forever (structurally permanent custody) with creator fees
 * routed to the BeneficiaryVault.
 *
 * DECISION: the fees-off splitter does NOT qualify, even though its custody is equally permanent.
 * `creatorFees` semantics promise a creator claim path through the vault; the fees-off splitter
 * forwards 100% of fees to the compounding recipient and registers no beneficiary. As of 2026-08-03
 * auction / crowd launches with creator fees off route to it too (see
 * {@link isAutocompoundPositionRecipient}), so the exclusion here exists purely so such a launch is
 * not misclassified as carrying creator fees.
 */
export declare function isCreatorFeesPositionRecipient(chainId: number, recipient: string): boolean;
/**
 * The current autocompound position recipient per chain: the fees-off FeeSplitter from
 * {@link INSTANT_LAUNCH_DEPLOYMENTS} (the `creatorFeesEnabled: false` entry; last one wins where the
 * append-only registry carries several). Derived from the registry, so a splitter redeploy only
 * requires appending a registry entry. Prefer {@link getAutocompoundPositionRecipient}.
 */
export declare const AUTOCOMPOUND_POSITION_RECIPIENTS: Partial<Record<number, Address>>;
/**
 * The position recipient for an auction / crowd launch with creator fees OFF on `chainId` — set it
 * as the launch's `MigratorParameters.positionRecipient` (in place of a per-launch lock-recipient
 * contract). It is the **fees-off** FeeSplitter of the chain's current fees-off deployment
 * ({@link getInstantLaunchStrategy} with `creatorFeesEnabled: false` — the same splitter fees-off
 * Instant Launch mints its positions to; as of 2026-08-03 crowd launches with fees off route here
 * too).
 *
 * What sending the migrated LP position there means:
 *  - no beneficiary is registered and nothing routes to the vault: the splitter forwards 100% of
 *    both fee sides to the chain's compounding claim recipient, auto-compounding them into the
 *    position;
 *  - custody is **permanent**: the splitter has no code path that transfers positions out, so the
 *    liquidity is locked forever by construction (no timelock involved).
 *
 * The creator-fees counterpart is {@link getCreatorFeesPositionRecipient}. Returns `undefined`
 * where the chain has no fees-off deployment.
 */
export declare function getAutocompoundPositionRecipient(chainId: number): Address | undefined;
/**
 * Whether `recipient` is an autocompound position recipient on `chainId`: the fees-off FeeSplitter
 * of any registry deployment for the chain — current or historical, since the registry is
 * append-only and indexed launches permanently reference the splitter they migrated to.
 * Case-insensitive. This is the classifier-side counterpart of
 * {@link getAutocompoundPositionRecipient}: a launch whose `MigratorParameters.positionRecipient`
 * matches is parked at the splitter forever (structurally permanent custody) with 100% of fees
 * auto-compounding — no creator fees (see the DECISION on {@link isCreatorFeesPositionRecipient},
 * which deliberately rejects these splitters).
 */
export declare function isAutocompoundPositionRecipient(chainId: number, recipient: string): boolean;
/** Which token standard a new-token launch targets (selects its address-derivation scheme). */
export type TokenFactoryKind = 'uerc20' | 'usuperc20';
export interface SelectedTokenFactory {
    factory: Address;
    kind: TokenFactoryKind;
}
/**
 * Picks the new-token factory for a chain. Selection is chain-driven: prefer the uERC20 factory and
 * fall back to the super-uERC20 one. Mainnet deploys both and resolves to uERC20. Returns `undefined`
 * when the chain deploys neither (new-token launches unsupported there).
 */
export declare function selectTokenFactory(addresses: LauncherAddresses): SelectedTokenFactory | undefined;