@mania-labs/mania-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1116 @@
+import { Address, Hash, PublicClient, WalletClient, Chain } from 'viem';
+
+/**
+ * Bonding curve state for a token
+ */
+interface BondingCurveState {
+    /** Virtual token reserves used in AMM calculation */
+    virtualTokenReserves: bigint;
+    /** Virtual ETH reserves used in AMM calculation */
+    virtualEthReserves: bigint;
+    /** Real token reserves available for purchase */
+    realTokenReserves: bigint;
+    /** Real ETH reserves collected from sales */
+    realEthReserves: bigint;
+    /** Total supply of the token */
+    tokenTotalSupply: bigint;
+    /** Whether the bonding curve has completed (reached migration threshold) */
+    complete: boolean;
+    /** Whether volume tracking is enabled for this token */
+    trackVolume: boolean;
+}
+/**
+ * Global protocol configuration
+ */
+interface GlobalState {
+    /** Whether the protocol has been initialized */
+    initialized: boolean;
+    /** Protocol authority address */
+    authority: Address;
+    /** Fee recipient address */
+    feeRecipient: Address;
+    /** Initial virtual token reserves for new curves */
+    initialVirtualTokenReserves: bigint;
+    /** Initial virtual ETH reserves for new curves */
+    initialVirtualEthReserves: bigint;
+    /** Initial real token reserves for new curves */
+    initialRealTokenReserves: bigint;
+    /** Token total supply for new tokens */
+    tokenTotalSupply: bigint;
+    /** Fee basis points (1 bp = 0.01%) */
+    feeBasisPoints: bigint;
+    /** Withdraw authority address */
+    withdrawAuthority: Address;
+    /** Whether migration to Uniswap is enabled */
+    enableMigrate: boolean;
+    /** Fee charged for pool migration */
+    poolMigrationFee: bigint;
+}
+/**
+ * Parameters for setting global protocol configuration
+ */
+interface SetParamsInput {
+    initialVirtualTokenReserves: bigint;
+    initialVirtualEthReserves: bigint;
+    initialRealTokenReserves: bigint;
+    tokenTotalSupply: bigint;
+    feeBasisPoints: bigint;
+    withdrawAuthority: Address;
+    enableMigrate: boolean;
+    poolMigrationFee: bigint;
+    feeRecipient: Address;
+}
+/**
+ * Token creation parameters
+ */
+interface CreateTokenParams {
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token metadata URI (e.g., IPFS link) */
+    uri: string;
+    /** Creator address (receives creator fees) */
+    creator: Address;
+}
+/**
+ * Parameters for creating a token and buying in a single transaction
+ */
+interface CreateAndBuyParams extends CreateTokenParams {
+    /** ETH amount to spend on initial buy */
+    buyAmountEth: bigint;
+    /** Minimum tokens to receive (slippage protection) */
+    minTokensOut: bigint;
+}
+/**
+ * Buy transaction parameters
+ */
+interface BuyParams {
+    /** Token address to buy */
+    token: Address;
+    /** ETH amount to spend */
+    amountEth: bigint;
+    /** Minimum tokens to receive (slippage protection) */
+    minTokensOut: bigint;
+    /** Recipient address for tokens (defaults to sender) */
+    recipient?: Address;
+}
+/**
+ * Sell transaction parameters
+ */
+interface SellParams {
+    /** Token address to sell */
+    token: Address;
+    /** Amount of tokens to sell */
+    amountTokens: bigint;
+    /** Minimum ETH to receive (slippage protection) */
+    minEthOut: bigint;
+}
+/**
+ * Migration parameters
+ */
+interface MigrateParams {
+    /** Token address to migrate */
+    token: Address;
+}
+/**
+ * Quote result for buy operations
+ */
+interface BuyQuote {
+    /** Tokens that would be received */
+    tokensOut: bigint;
+    /** Fee amount in ETH */
+    fee: bigint;
+    /** Net ETH after fees */
+    netEth: bigint;
+    /** Price per token in ETH */
+    pricePerToken: bigint;
+}
+/**
+ * Quote result for sell operations
+ */
+interface SellQuote {
+    /** ETH that would be received (before fees) */
+    ethOutGross: bigint;
+    /** Fee amount in ETH */
+    fee: bigint;
+    /** Net ETH after fees */
+    ethOutNet: bigint;
+    /** Price per token in ETH */
+    pricePerToken: bigint;
+}
+/**
+ * Token information combining on-chain data
+ */
+interface TokenInfo {
+    /** Token contract address */
+    address: Address;
+    /** Bonding curve state */
+    bondingCurve: BondingCurveState;
+    /** Current token price in ETH */
+    currentPrice: bigint;
+    /** Market cap in ETH */
+    marketCapEth: bigint;
+    /** Progress towards migration (0-100) */
+    migrationProgress: number;
+}
+/**
+ * Transaction result
+ */
+interface TransactionResult {
+    /** Transaction hash */
+    hash: Hash;
+    /** Whether the transaction was successful */
+    success: boolean;
+}
+/**
+ * Event types emitted by the contract
+ */
+interface CreateEvent {
+    name: string;
+    symbol: string;
+    uri: string;
+    mint: Address;
+    user: Address;
+    creator: Address;
+    timestamp: bigint;
+}
+interface TradeEvent {
+    mint: Address;
+    ethAmount: bigint;
+    tokenAmount: bigint;
+    isBuy: boolean;
+    user: Address;
+    timestamp: bigint;
+    virtualEthReserves: bigint;
+    virtualTokenReserves: bigint;
+    realEthReserves: bigint;
+    realTokenReserves: bigint;
+}
+interface CompleteEvent {
+    user: Address;
+    mint: Address;
+    timestamp: bigint;
+}
+interface MigrationEvent {
+    user: Address;
+    mint: Address;
+    mintAmount: bigint;
+    ethAmount: bigint;
+    poolMigrationFee: bigint;
+    timestamp: bigint;
+    pool: Address;
+}
+/**
+ * SDK Configuration
+ */
+interface ManiaSDKConfig {
+    /** ManiaFactory contract address */
+    factoryAddress: Address;
+    /** RPC URL or viem public client */
+    rpcUrl?: string;
+    /** Chain ID */
+    chainId?: number;
+}
+/**
+ * Slippage configuration
+ */
+interface SlippageConfig {
+    /** Slippage tolerance in basis points (e.g., 100 = 1%) */
+    slippageBps: number;
+}
+
+/**
+ * BondingCurve class for handling bonding curve calculations and state
+ *
+ * The bonding curve uses a constant product formula (x * y = k) similar to Uniswap V2,
+ * but with virtual reserves to provide initial liquidity.
+ */
+declare class BondingCurve {
+    private state;
+    private feeBasisPoints;
+    constructor(state: BondingCurveState, feeBasisPoints: bigint);
+    /**
+     * Get the current bonding curve state
+     */
+    getState(): BondingCurveState;
+    /**
+     * Check if the bonding curve is complete (reached migration threshold)
+     */
+    isComplete(): boolean;
+    /**
+     * Check if the bonding curve has been migrated (all reserves are 0)
+     */
+    isMigrated(): boolean;
+    /**
+     * Get the current token price in ETH (wei per token)
+     *
+     * Price is calculated as: virtualEthReserves / virtualTokenReserves
+     */
+    getCurrentPrice(): bigint;
+    /**
+     * Get the market cap in ETH
+     *
+     * Market cap = current price * total supply
+     */
+    getMarketCapEth(): bigint;
+    /**
+     * Get the progress towards migration threshold (0-100)
+     */
+    getMigrationProgress(): number;
+    /**
+     * Calculate ETH remaining until migration
+     */
+    getEthUntilMigration(): bigint;
+    /**
+     * Get a quote for buying tokens with a specific ETH amount
+     *
+     * @param ethAmount - Amount of ETH to spend (in wei)
+     * @returns Quote with tokens out, fees, and price impact
+     */
+    getBuyQuote(ethAmount: bigint): BuyQuote;
+    /**
+     * Get a quote for selling tokens
+     *
+     * @param tokenAmount - Amount of tokens to sell
+     * @returns Quote with ETH out, fees, and price impact
+     */
+    getSellQuote(tokenAmount: bigint): SellQuote;
+    /**
+     * Calculate minimum tokens out with slippage tolerance
+     *
+     * @param ethAmount - Amount of ETH to spend
+     * @param slippageBps - Slippage tolerance in basis points (e.g., 100 = 1%)
+     * @returns Minimum tokens to receive
+     */
+    calculateMinTokensOut(ethAmount: bigint, slippageBps: number): bigint;
+    /**
+     * Calculate minimum ETH out with slippage tolerance
+     *
+     * @param tokenAmount - Amount of tokens to sell
+     * @param slippageBps - Slippage tolerance in basis points (e.g., 100 = 1%)
+     * @returns Minimum ETH to receive
+     */
+    calculateMinEthOut(tokenAmount: bigint, slippageBps: number): bigint;
+    /**
+     * Calculate price impact for a buy order
+     *
+     * @param ethAmount - Amount of ETH to spend
+     * @returns Price impact as a percentage (e.g., 2.5 = 2.5%)
+     */
+    calculateBuyPriceImpact(ethAmount: bigint): number;
+    /**
+     * Calculate price impact for a sell order
+     *
+     * @param tokenAmount - Amount of tokens to sell
+     * @returns Price impact as a percentage (negative for sells)
+     */
+    calculateSellPriceImpact(tokenAmount: bigint): number;
+    /**
+     * Check if a buy would exceed the migration threshold
+     *
+     * @param ethAmount - Amount of ETH to spend
+     * @returns True if the buy would exceed threshold
+     */
+    wouldExceedMigrationThreshold(ethAmount: bigint): boolean;
+    /**
+     * Calculate maximum ETH that can be spent before hitting migration threshold
+     *
+     * @returns Maximum ETH amount (in wei)
+     */
+    getMaxBuyAmount(): bigint;
+    /**
+     * Update the internal state (used after trades)
+     */
+    updateState(newState: BondingCurveState): void;
+    /**
+     * Create a BondingCurve instance from raw contract data
+     */
+    static fromContractData(data: readonly [bigint, bigint, bigint, bigint, bigint, boolean, boolean], feeBasisPoints: bigint): BondingCurve;
+}
+/**
+ * Utility function to calculate tokens out without instantiating a class
+ */
+declare function calculateBuyAmount(virtualTokenReserves: bigint, virtualEthReserves: bigint, ethAmount: bigint, feeBasisPoints: bigint): bigint;
+/**
+ * Utility function to calculate ETH out without instantiating a class
+ */
+declare function calculateSellAmount(virtualTokenReserves: bigint, virtualEthReserves: bigint, tokenAmount: bigint, feeBasisPoints: bigint): bigint;
+
+/**
+ * ManiaSDK - Official SDK for interacting with the Mania Protocol
+ *
+ * Mania is an EVM-based token launchpad using bonding curves. Tokens are created
+ * with an initial bonding curve that allows trading until a migration threshold
+ * (4 ETH) is reached. Once complete, liquidity is migrated to Uniswap V3.
+ */
+declare class ManiaSDK {
+    publicClient: PublicClient;
+    walletClient: WalletClient | null;
+    readonly factoryAddress: Address;
+    readonly chainId: number;
+    /**
+     * Create a new ManiaSDK instance
+     *
+     * @param config - SDK configuration
+     * @param config.factoryAddress - ManiaFactory contract address
+     * @param config.rpcUrl - RPC URL for the chain
+     * @param config.chainId - Chain ID (optional, will be fetched if not provided)
+     */
+    constructor(config: ManiaSDKConfig);
+    /**
+     * Create SDK instance from chain ID using default configuration
+     *
+     * @param chainId - Chain ID
+     * @param rpcUrl - RPC URL (optional, uses public RPC if not provided)
+     * @returns ManiaSDK instance
+     */
+    static fromChainId(chainId: number, rpcUrl?: string): ManiaSDK;
+    /**
+     * Connect a wallet for signing transactions
+     *
+     * @param privateKey - Private key (with or without 0x prefix)
+     * @param chain - Viem chain object
+     */
+    connectWallet(privateKey: string, chain: Chain): void;
+    /**
+     * Connect an existing wallet client
+     *
+     * @param walletClient - Viem wallet client
+     */
+    setWalletClient(walletClient: WalletClient): void;
+    /**
+     * Set a custom public client
+     *
+     * @param publicClient - Viem public client
+     */
+    setPublicClient(publicClient: PublicClient): void;
+    /**
+     * Get the connected wallet address
+     */
+    getWalletAddress(): Address | undefined;
+    /**
+     * Get global protocol configuration
+     */
+    getGlobalState(): Promise<GlobalState>;
+    /**
+     * Get bonding curve state for a token
+     *
+     * @param token - Token address
+     */
+    getBondingCurve(token: Address): Promise<BondingCurveState>;
+    /**
+     * Get a BondingCurve instance for calculations
+     *
+     * @param token - Token address
+     */
+    getBondingCurveInstance(token: Address): Promise<BondingCurve>;
+    /**
+     * Get comprehensive token information
+     *
+     * @param token - Token address
+     */
+    getTokenInfo(token: Address): Promise<TokenInfo>;
+    /**
+     * Get buy quote from contract
+     *
+     * @param token - Token address
+     * @param ethAmount - ETH amount in wei
+     */
+    getBuyQuote(token: Address, ethAmount: bigint): Promise<bigint>;
+    /**
+     * Get sell quote from contract
+     *
+     * @param token - Token address
+     * @param tokenAmount - Token amount
+     */
+    getSellQuote(token: Address, tokenAmount: bigint): Promise<bigint>;
+    /**
+     * Get fee for a given amount
+     *
+     * @param amount - Amount in wei
+     */
+    getFee(amount: bigint): Promise<bigint>;
+    /**
+     * Get user volume
+     *
+     * @param user - User address
+     */
+    getUserVolume(user: Address): Promise<bigint>;
+    private getConnectedWallet;
+    /**
+     * Create a new token with bonding curve
+     *
+     * @param params - Token creation parameters
+     * @returns Transaction result with token address
+     */
+    create(params: CreateTokenParams): Promise<TransactionResult & {
+        tokenAddress?: Address;
+    }>;
+    /**
+     * Create a new token and buy in a single transaction
+     *
+     * @param params - Creation and buy parameters
+     * @returns Transaction result with token address
+     */
+    createAndBuy(params: CreateAndBuyParams): Promise<TransactionResult & {
+        tokenAddress?: Address;
+    }>;
+    /**
+     * Buy tokens from bonding curve
+     *
+     * @param params - Buy parameters
+     * @returns Transaction result
+     */
+    buy(params: BuyParams): Promise<TransactionResult>;
+    /**
+     * Buy tokens with automatic slippage calculation
+     *
+     * @param token - Token address
+     * @param ethAmount - ETH amount to spend
+     * @param slippageBps - Slippage tolerance in basis points (default: 100 = 1%)
+     */
+    buyWithSlippage(token: Address, ethAmount: bigint, slippageBps?: number): Promise<TransactionResult>;
+    /**
+     * Sell tokens to bonding curve
+     *
+     * @param params - Sell parameters
+     * @returns Transaction result
+     */
+    sell(params: SellParams): Promise<TransactionResult>;
+    /**
+     * Sell tokens with automatic slippage calculation
+     *
+     * @param token - Token address
+     * @param tokenAmount - Token amount to sell
+     * @param slippageBps - Slippage tolerance in basis points (default: 100 = 1%)
+     */
+    sellWithSlippage(token: Address, tokenAmount: bigint, slippageBps?: number): Promise<TransactionResult>;
+    /**
+     * Migrate liquidity to Uniswap V3
+     *
+     * @param params - Migration parameters
+     * @returns Transaction result with pool address
+     */
+    migrate(params: MigrateParams): Promise<TransactionResult & {
+        poolAddress?: Address;
+    }>;
+    /**
+     * Watch for new token creation events
+     *
+     * @param callback - Callback function for each event
+     * @returns Unwatch function
+     */
+    watchCreateEvents(callback: (event: CreateEvent) => void): () => void;
+    /**
+     * Watch for trade events on a specific token
+     *
+     * @param token - Token address (optional, watches all if not provided)
+     * @param callback - Callback function for each event
+     * @returns Unwatch function
+     */
+    watchTradeEvents(token: Address | undefined, callback: (event: TradeEvent) => void): () => void;
+    /**
+     * Watch for bonding curve completion events
+     *
+     * @param callback - Callback function for each event
+     * @returns Unwatch function
+     */
+    watchCompleteEvents(callback: (event: CompleteEvent) => void): () => void;
+    /**
+     * Watch for migration events
+     *
+     * @param callback - Callback function for each event
+     * @returns Unwatch function
+     */
+    watchMigrationEvents(callback: (event: MigrationEvent) => void): () => void;
+    /**
+     * Check if a token's bonding curve is complete
+     *
+     * @param token - Token address
+     */
+    isComplete(token: Address): Promise<boolean>;
+    /**
+     * Check if a token has been migrated
+     *
+     * @param token - Token address
+     */
+    isMigrated(token: Address): Promise<boolean>;
+    /**
+     * Get the factory contract address
+     */
+    getFactoryAddress(): Address;
+    /**
+     * Get the public client
+     */
+    getPublicClient(): PublicClient;
+    /**
+     * Get the wallet client
+     */
+    getWalletClient(): WalletClient | null;
+}
+
+/**
+ * Protocol fee constants (matching smart contract)
+ */
+declare const PROTOCOL_FEE_BASIS_POINTS = 70n;
+declare const CREATOR_FEE_BASIS_POINTS = 30n;
+declare const TOTAL_FEE_BASIS_POINTS: bigint;
+declare const MAX_FEE_BASIS_POINTS = 1000n;
+/**
+ * Migration constants
+ */
+declare const MIGRATION_THRESHOLD = 4000000000000000000n;
+declare const TOKENS_FOR_LP = 206900000000000000000000000n;
+declare const MAX_MIGRATE_FEES = 300000000000000n;
+/**
+ * Uniswap V3 constants
+ */
+declare const UNISWAP_FEE_TIER = 3000;
+declare const TICK_LOWER = -887220;
+declare const TICK_UPPER = 887220;
+/**
+ * Default slippage tolerance
+ */
+declare const DEFAULT_SLIPPAGE_BPS = 100;
+/**
+ * Basis points denominator
+ */
+declare const BPS_DENOMINATOR = 10000n;
+/**
+ * Chain configurations
+ */
+interface ChainConfig {
+    chainId: number;
+    name: string;
+    factoryAddress: Address;
+    wethAddress: Address;
+    nonfungiblePositionManager: Address;
+    uniswapV3Factory: Address;
+    blockExplorer: string;
+}
+/**
+ * Supported chain configurations
+ * Add your deployed contract addresses here
+ */
+declare const CHAIN_CONFIGS: Record<number, ChainConfig>;
+/**
+ * Get chain configuration by chain ID
+ */
+declare function getChainConfig(chainId: number): ChainConfig | undefined;
+
+/**
+ * Format a bigint wei value to a human-readable ETH string
+ */
+declare function formatEthValue(wei: bigint, decimals?: number): string;
+/**
+ * Format a token amount to a human-readable string
+ */
+declare function formatTokenAmount(amount: bigint, decimals?: number): string;
+/**
+ * Parse an ETH string to wei
+ */
+declare function parseEthValue(eth: string): bigint;
+/**
+ * Calculate slippage-adjusted minimum amount
+ */
+declare function calculateWithSlippage(amount: bigint, slippageBps: number): bigint;
+/**
+ * Calculate percentage of migration threshold reached
+ */
+declare function calculateMigrationProgress(realEthReserves: bigint): number;
+/**
+ * Format price with appropriate precision
+ */
+declare function formatPrice(priceWei: bigint): string;
+/**
+ * Format market cap in ETH
+ */
+declare function formatMarketCap(marketCapWei: bigint): string;
+/**
+ * Validate Ethereum address format
+ */
+declare function isValidAddress(address: string): address is Address;
+/**
+ * Truncate address for display
+ */
+declare function truncateAddress(address: Address, chars?: number): string;
+/**
+ * Convert basis points to percentage
+ */
+declare function bpsToPercent(bps: number | bigint): number;
+/**
+ * Convert percentage to basis points
+ */
+declare function percentToBps(percent: number): number;
+/**
+ * Calculate price impact as a percentage
+ */
+declare function calculatePriceImpact(currentPrice: bigint, newPrice: bigint): number;
+/**
+ * Sleep utility for polling
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry a function with exponential backoff
+ */
+declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelayMs?: number): Promise<T>;
+
+declare const MANIA_FACTORY_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "bondingCurves";
+    readonly inputs: readonly [{
+        readonly name: "mint";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "virtualTokenReserves";
+        readonly type: "uint256";
+    }, {
+        readonly name: "virtualEthReserves";
+        readonly type: "uint64";
+    }, {
+        readonly name: "realTokenReserves";
+        readonly type: "uint256";
+    }, {
+        readonly name: "realEthReserves";
+        readonly type: "uint64";
+    }, {
+        readonly name: "tokenTotalSupply";
+        readonly type: "uint256";
+    }, {
+        readonly name: "complete";
+        readonly type: "bool";
+    }, {
+        readonly name: "trackVolume";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "buy";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "minTokensOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "create";
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+    }, {
+        readonly name: "uri";
+        readonly type: "string";
+    }, {
+        readonly name: "creator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "createAndBuy";
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+    }, {
+        readonly name: "uri";
+        readonly type: "string";
+    }, {
+        readonly name: "creator";
+        readonly type: "address";
+    }, {
+        readonly name: "minTokensOut";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "getBondingCurve";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "curve";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "virtualTokenReserves";
+            readonly type: "uint256";
+        }, {
+            readonly name: "virtualEthReserves";
+            readonly type: "uint64";
+        }, {
+            readonly name: "realTokenReserves";
+            readonly type: "uint256";
+        }, {
+            readonly name: "realEthReserves";
+            readonly type: "uint64";
+        }, {
+            readonly name: "tokenTotalSupply";
+            readonly type: "uint256";
+        }, {
+            readonly name: "complete";
+            readonly type: "bool";
+        }, {
+            readonly name: "trackVolume";
+            readonly type: "bool";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getBuyQuote";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "ethAmount";
+        readonly type: "uint64";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokenAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getFee";
+    readonly inputs: readonly [{
+        readonly name: "amount";
+        readonly type: "uint64";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "fee";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getSellQuote";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "ethOutput";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "global";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "initialized";
+        readonly type: "bool";
+    }, {
+        readonly name: "authority";
+        readonly type: "address";
+    }, {
+        readonly name: "feeRecipient";
+        readonly type: "address";
+    }, {
+        readonly name: "initialVirtualTokenReserves";
+        readonly type: "uint256";
+    }, {
+        readonly name: "initialVirtualEthReserves";
+        readonly type: "uint64";
+    }, {
+        readonly name: "initialRealTokenReserves";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokenTotalSupply";
+        readonly type: "uint256";
+    }, {
+        readonly name: "feeBasisPoints";
+        readonly type: "uint64";
+    }, {
+        readonly name: "withdrawAuthority";
+        readonly type: "address";
+    }, {
+        readonly name: "enableMigrate";
+        readonly type: "bool";
+    }, {
+        readonly name: "poolMigrationFee";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "migrate";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "sell";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "minEthOutput";
+        readonly type: "uint64";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "userVolume";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "volume";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "CreateEvent";
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "uri";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "mint";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "creator";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "TradeEvent";
+    readonly inputs: readonly [{
+        readonly name: "mint";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "ethAmount";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }, {
+        readonly name: "tokenAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "isBuy";
+        readonly type: "bool";
+        readonly indexed: false;
+    }, {
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "virtualEthReserves";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }, {
+        readonly name: "virtualTokenReserves";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "realEthReserves";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }, {
+        readonly name: "realTokenReserves";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "CompleteEvent";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "mint";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "CompleteManiaAmmMigrationEvent";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "mint";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "mintAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "ethAmount";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }, {
+        readonly name: "poolMigrationFee";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "pool";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly anonymous: false;
+}];
+declare const ERC20_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "name";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "allowance";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "transfer";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}];
+
+export { BPS_DENOMINATOR, BondingCurve, type BondingCurveState, type BuyParams, type BuyQuote, CHAIN_CONFIGS, CREATOR_FEE_BASIS_POINTS, type ChainConfig, type CompleteEvent, type CreateAndBuyParams, type CreateEvent, type CreateTokenParams, DEFAULT_SLIPPAGE_BPS, ERC20_ABI, type GlobalState, MANIA_FACTORY_ABI, MAX_FEE_BASIS_POINTS, MAX_MIGRATE_FEES, MIGRATION_THRESHOLD, ManiaSDK, type ManiaSDKConfig, type MigrateParams, type MigrationEvent, PROTOCOL_FEE_BASIS_POINTS, type SellParams, type SellQuote, type SetParamsInput, type SlippageConfig, TICK_LOWER, TICK_UPPER, TOKENS_FOR_LP, TOTAL_FEE_BASIS_POINTS, type TokenInfo, type TradeEvent, type TransactionResult, UNISWAP_FEE_TIER, bpsToPercent, calculateBuyAmount, calculateMigrationProgress, calculatePriceImpact, calculateSellAmount, calculateWithSlippage, formatEthValue, formatMarketCap, formatPrice, formatTokenAmount, getChainConfig, isValidAddress, parseEthValue, percentToBps, sleep, truncateAddress, withRetry };